OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5542 from akva2/float_support1

Browse Source 
Add float support to simulators: Batch 1
This commit is contained in:
Bård Skaflestad 2024-08-20 09:29:40 +02:00 committed by GitHub
commit afe34e1868
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
61 changed files with 1143 additions and 744 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CMakeLists.txt
View File

@ -22,6 +22,7 @@ option(SIBLING_SEARCH "Search for other modules in sibling directories?" ON)
set( USE_OPENMP_DEFAULT OFF ) # Use of OpenMP is considered experimental
option(BUILD_FLOW "Build the production oriented flow simulator?" ON)
option(BUILD_FLOW_VARIANTS "Build the variants for flow by default?" OFF)
option(BUILD_FLOW_FLOAT_VARIANTS "Build the variants for flow using float?" OFF)
option(BUILD_FLOW_POLY_GRID "Build flow blackoil with polyhedral grid" OFF)
option(OPM_ENABLE_PYTHON "Enable python bindings?" OFF)
option(OPM_ENABLE_PYTHON_TESTS "Enable tests for the python bindings?" ON)
@ -288,6 +289,10 @@ macro (config_hook)
include_directories(${EXTRA_INCLUDES})
include(UseDamaris)
if(BUILD_FLOW_FLOAT_VARIANTS)
set(FLOW_INSTANTIATE_FLOAT 1)
endif()
endmacro (config_hook)
macro (prereqs_hook)

1
opm-simulators-prereqs.cmake
View File

@ -24,6 +24,7 @@ set (opm-simulators_CONFIG_VAR
HAVE_HDF5
USE_HIP
USE_TRACY
FLOW_INSTANTIATE_FLOAT
)
# dependencies

46
opm/simulators/flow/FlowGenericProblem.cpp
View File

@ -43,26 +43,48 @@
namespace Opm {
template class FlowGenericProblem<Dune::GridView<Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>,
BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>>;
#define INSTANTIATE_TYPE(T) \
template class FlowGenericProblem< \
Dune::GridView< \
Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>, \
BlackOilFluidSystem<T,BlackOilDefaultIndexTraits>>;
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
#if HAVE_DUNE_FEM
#if DUNE_VERSION_GTE(DUNE_FEM, 2, 9)
using GV = Dune::Fem::AdaptiveLeafGridPart<Dune::CpGrid,
(Dune::PartitionIteratorType)4,
false>;
template class FlowGenericProblem<GV,
BlackOilFluidSystem<double, BlackOilDefaultIndexTraits>>;
#define INSTANTIATE_FEM_TYPE(T) \
template class FlowGenericProblem<GV, \
BlackOilFluidSystem<T, BlackOilDefaultIndexTraits>>;
#else
template class FlowGenericProblem<Dune::GridView<Dune::Fem::GridPart2GridViewTraits<Dune::Fem::AdaptiveLeafGridPart<Dune::CpGrid, Dune::PartitionIteratorType(4), false>>>,
BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>>;
template class FlowGenericProblem<Dune::Fem::GridPart2GridViewImpl<
Dune::Fem::AdaptiveLeafGridPart<
Dune::CpGrid,
Dune::PartitionIteratorType(4),
false> >,
BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>>;
#define INSTANTIATE_FEM_TYPE(T) \
template class FlowGenericProblem<Dune::GridView< \
Dune::Fem::GridPart2GridViewTraits< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), false>>>, \
BlackOilFluidSystem<T,BlackOilDefaultIndexTraits>>; \
template class FlowGenericProblem<Dune::Fem::GridPart2GridViewImpl< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), \
false> >, \
BlackOilFluidSystem<T,BlackOilDefaultIndexTraits>>;
#endif
INSTANTIATE_FEM_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_FEM_TYPE(float)
#endif
#endif // HAVE_DUNE_FEM
} // end namespace Opm

45
opm/simulators/flow/FlowGenericProblem_impl.hpp
View File

@ -146,8 +146,10 @@ readRockParameters_(const std::vector<Scalar>& cellCenterDepths,
{
const auto& comp = rock_config.comp();
rockParams_.clear();
for (const auto& c : comp)
rockParams_.push_back( { c.pref, c.compressibility } );
for (const auto& c : comp) {
rockParams_.push_back({static_cast<Scalar>(c.pref),
static_cast<Scalar>(c.compressibility)});
}
}
// read the parameters for water-induced rock compaction
@ -495,21 +497,28 @@ readBlackoilExtentionsInitialConditions_(std::size_t numDof,
bool enablePolymerMolarWeight,
bool enableMICP)
{
if (enableSolvent) {
if (eclState_.fieldProps().has_double("SSOL"))
solventSaturation_ = eclState_.fieldProps().get_double("SSOL");
else
solventSaturation_.resize(numDof, 0.0);
auto getArray = [](const std::vector<double>& input)
{
if constexpr (std::is_same_v<Scalar,double>) {
return input;
} else {
return std::vector<Scalar>{input.begin(), input.end()};
}
};
//if (eclState_.fieldProps().has_double("SSOL"))
// solventRsw_ = eclState_.fieldProps().get_double("SSOL");
//else
solventRsw_.resize(numDof, 0.0);
if (enableSolvent) {
if (eclState_.fieldProps().has_double("SSOL")) {
solventSaturation_ = getArray(eclState_.fieldProps().get_double("SSOL"));
} else {
solventSaturation_.resize(numDof, 0.0);
}
solventRsw_.resize(numDof, 0.0);
}
if (enablePolymer) {
if (eclState_.fieldProps().has_double("SPOLY")) {
polymer_.concentration = eclState_.fieldProps().get_double("SPOLY");
polymer_.concentration = getArray(eclState_.fieldProps().get_double("SPOLY"));
} else {
polymer_.concentration.resize(numDof, 0.0);
}
@ -517,7 +526,7 @@ readBlackoilExtentionsInitialConditions_(std::size_t numDof,
if (enablePolymerMolarWeight) {
if (eclState_.fieldProps().has_double("SPOLYMW")) {
polymer_.moleWeight = eclState_.fieldProps().get_double("SPOLYMW");
polymer_.moleWeight = getArray(eclState_.fieldProps().get_double("SPOLYMW"));
} else {
polymer_.moleWeight.resize(numDof, 0.0);
}
@ -525,27 +534,27 @@ readBlackoilExtentionsInitialConditions_(std::size_t numDof,
if (enableMICP) {
if (eclState_.fieldProps().has_double("SMICR")) {
micp_.microbialConcentration = eclState_.fieldProps().get_double("SMICR");
micp_.microbialConcentration = getArray(eclState_.fieldProps().get_double("SMICR"));
} else {
micp_.microbialConcentration.resize(numDof, 0.0);
}
if (eclState_.fieldProps().has_double("SOXYG")) {
micp_.oxygenConcentration = eclState_.fieldProps().get_double("SOXYG");
micp_.oxygenConcentration = getArray(eclState_.fieldProps().get_double("SOXYG"));
} else {
micp_.oxygenConcentration.resize(numDof, 0.0);
}
if (eclState_.fieldProps().has_double("SUREA")) {
micp_.ureaConcentration = eclState_.fieldProps().get_double("SUREA");
micp_.ureaConcentration = getArray(eclState_.fieldProps().get_double("SUREA"));
} else {
micp_.ureaConcentration.resize(numDof, 0.0);
}
if (eclState_.fieldProps().has_double("SBIOF")) {
micp_.biofilmConcentration = eclState_.fieldProps().get_double("SBIOF");
micp_.biofilmConcentration = getArray(eclState_.fieldProps().get_double("SBIOF"));
} else {
micp_.biofilmConcentration.resize(numDof, 0.0);
}
if (eclState_.fieldProps().has_double("SCALC")) {
micp_.calciteConcentration = eclState_.fieldProps().get_double("SCALC");
micp_.calciteConcentration = getArray(eclState_.fieldProps().get_double("SCALC"));
} else {
micp_.calciteConcentration.resize(numDof, 0.0);
}

4
opm/simulators/flow/FlowProblemParameters.cpp
View File

@ -88,4 +88,8 @@ void registerFlowProblemParameters()
template void registerFlowProblemParameters<double>();
#if FLOW_INSTANTIATE_FLOAT
template void registerFlowProblemParameters<float>();
#endif
}

4
opm/simulators/flow/FlowUtils.cpp
View File

@ -264,4 +264,8 @@ void hideUnusedParameters()
template void hideUnusedParameters<double>();
#if FLOW_INSTANTIATE_FLOAT
template void hideUnusedParameters<float>();
#endif
} // namespace Opm::detail

92
opm/simulators/flow/GenericCpGridVanguard.cpp
View File

@ -588,53 +588,67 @@ computeCellThickness(const typename GridView::template Codim<0>::Entity& element
zz2 /=4;
return zz2-zz1;
}
template class GenericCpGridVanguard<
Dune::MultipleCodimMultipleGeomTypeMapper<
Dune::GridView<
Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>>,
Dune::GridView<
Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>,
double>;
#define INSTANTIATE_TYPE(T) \
template class GenericCpGridVanguard< \
Dune::MultipleCodimMultipleGeomTypeMapper< \
Dune::GridView< \
Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>>, \
Dune::GridView< \
Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>, \
T>;
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
#if HAVE_DUNE_FEM
#if DUNE_VERSION_GTE(DUNE_FEM, 2, 9)
using GV = Dune::Fem::AdaptiveLeafGridPart<Dune::CpGrid,
(Dune::PartitionIteratorType)4,
false>;
template class GenericCpGridVanguard<Dune::MultipleCodimMultipleGeomTypeMapper<GV>,
GV,
double>;
#define INSTANTIATE_FEM_TYPE(T) \
template class GenericCpGridVanguard<Dune::MultipleCodimMultipleGeomTypeMapper<GV>, \
GV, \
T>;
#else
template class GenericCpGridVanguard<
Dune::MultipleCodimMultipleGeomTypeMapper<
Dune::GridView<
Dune::Fem::GridPart2GridViewTraits<
Dune::Fem::AdaptiveLeafGridPart<
Dune::CpGrid,
Dune::PartitionIteratorType(4),
false>>>>,
Dune::GridView<
Dune::Fem::GridPart2GridViewTraits<
Dune::Fem::AdaptiveLeafGridPart<
Dune::CpGrid,
Dune::PartitionIteratorType(4),
false>>>,
double>;
template class GenericCpGridVanguard<
Dune::MultipleCodimMultipleGeomTypeMapper<
Dune::Fem::GridPart2GridViewImpl<
Dune::Fem::AdaptiveLeafGridPart<
Dune::CpGrid,
Dune::PartitionIteratorType(4),
false>>>,
Dune::Fem::GridPart2GridViewImpl<
Dune::Fem::AdaptiveLeafGridPart<
Dune::CpGrid,
Dune::PartitionIteratorType(4),
false> >,
double>;
#define INSTANTIATE_FEM_TYPE(T) \
template class GenericCpGridVanguard< \
Dune::MultipleCodimMultipleGeomTypeMapper< \
Dune::GridView< \
Dune::Fem::GridPart2GridViewTraits< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), \
false>>>>, \
Dune::GridView< \
Dune::Fem::GridPart2GridViewTraits< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), \
false>>>, \
T>; \
template class GenericCpGridVanguard< \
Dune::MultipleCodimMultipleGeomTypeMapper< \
Dune::Fem::GridPart2GridViewImpl< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), \
false>>>, \
Dune::Fem::GridPart2GridViewImpl< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), \
false> >, \
T>;
#endif
INSTANTIATE_FEM_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_FEM_TYPE(float)
#endif
#endif // HAVE_DUNE_FEM
} // namespace Opm

77
opm/simulators/flow/GenericThresholdPressure.cpp
View File

@ -38,39 +38,66 @@
namespace Opm {
template class GenericThresholdPressure<Dune::CpGrid,
Dune::GridView<Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>,
Dune::MultipleCodimMultipleGeomTypeMapper<Dune::GridView<Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>>,
double>;
#define INSTANTIATE_TYPE(T) \
template class GenericThresholdPressure<Dune::CpGrid, \
Dune::GridView< \
Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>, \
Dune::MultipleCodimMultipleGeomTypeMapper< \
Dune::GridView<Dune::DefaultLeafGridViewTraits< \
Dune::CpGrid>>>, \
T>;
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
#if HAVE_DUNE_FEM
#if DUNE_VERSION_GTE(DUNE_FEM, 2, 9)
using GV = Dune::Fem::AdaptiveLeafGridPart<Dune::CpGrid,
(Dune::PartitionIteratorType)4,
false>;
template class GenericThresholdPressure<Dune::CpGrid,
GV,
Dune::MultipleCodimMultipleGeomTypeMapper<GV>,
double>;
#define INSTANTIATE_FEM_TYPE(T) \
template class GenericThresholdPressure<Dune::CpGrid, \
GV, \
Dune::MultipleCodimMultipleGeomTypeMapper<GV>, \
T>;
#else
template class GenericThresholdPressure<Dune::CpGrid,
Dune::GridView<Dune::Fem::GridPart2GridViewTraits<Dune::Fem::AdaptiveLeafGridPart<Dune::CpGrid, Dune::PartitionIteratorType(4), false>>>,
Dune::MultipleCodimMultipleGeomTypeMapper<Dune::GridView<Dune::Fem::GridPart2GridViewTraits<Dune::Fem::AdaptiveLeafGridPart<Dune::CpGrid, Dune::PartitionIteratorType(4), false>>>>,
double>;
template class GenericThresholdPressure<Dune::CpGrid,
Dune::Fem::GridPart2GridViewImpl<
Dune::Fem::AdaptiveLeafGridPart<
Dune::CpGrid,
Dune::PartitionIteratorType(4),
false> >,
Dune::MultipleCodimMultipleGeomTypeMapper<
Dune::Fem::GridPart2GridViewImpl<
Dune::Fem::AdaptiveLeafGridPart<
Dune::CpGrid,
Dune::PartitionIteratorType(4),
false>>>,
double>;
#define INSTANTIATE_FEM_TYPE(T) \
template class GenericThresholdPressure<Dune::CpGrid, \
Dune::GridView< \
Dune::Fem::GridPart2GridViewTraits< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), false>>>, \
Dune::MultipleCodimMultipleGeomTypeMapper< \
Dune::GridView<Dune::Fem::GridPart2GridViewTraits< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), false>>>>, \
T>; \
template class GenericThresholdPressure<Dune::CpGrid, \
Dune::Fem::GridPart2GridViewImpl< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), \
false> >, \
Dune::MultipleCodimMultipleGeomTypeMapper< \
Dune::Fem::GridPart2GridViewImpl< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), \
false>>>, \
T>;
#endif
INSTANTIATE_FEM_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_FEM_TYPE(float)
#endif
#endif // HAVE_DUNE_FEM
} // namespace Opm

4
opm/simulators/flow/GenericThresholdPressure.hpp
View File

@ -74,8 +74,8 @@ public:
*
* This is used for the restart capability.
*/
void setFromRestart(const std::vector<Scalar>& values)
{ thpres_ = values; }
void setFromRestart(const std::vector<double>& values)
{ thpres_.assign(values.begin(), values.end()); }
//! \brief Returns a fully expanded vector for restart file writing.
//! \details Returns the union of explicitly configured entries and defaulted values.

5
opm/simulators/flow/LogOutputHelper.cpp
View File

@ -1000,4 +1000,9 @@ pressureUnitConvert_(Scalar& pav) const
template class LogOutputHelper<double>;
#if FLOW_INSTANTIATE_FLOAT
template class LogOutputHelper<float>;
#endif
} // namespace Opm

38
opm/simulators/flow/MixingRateControls.cpp
View File

@ -302,26 +302,36 @@ updateConvectiveDRsDt_(const unsigned compressedDofIdx,
// Also we restrict the effect of convective mixing to positive density differences
// i.e. we only allow for fingers moving downward
Scalar co2Density = FluidSystem::gasPvt().inverseFormationVolumeFactor(pvtRegionIndex,
t,p,0.0 /*=Rv*/, 0.0 /*=Rvw*/) * FluidSystem::referenceDensity(FluidSystem::gasPhaseIdx, pvtRegionIndex);
Scalar factor = 1.0;
Scalar X = (rs - rssat * sg) / (rssat * ( 1.0 - sg));
Scalar co2Density =
FluidSystem::gasPvt().inverseFormationVolumeFactor(pvtRegionIndex,t,p,Scalar{0.0} /*=Rv*/, Scalar{0.0} /*=Rvw*/) *
FluidSystem::referenceDensity(FluidSystem::gasPhaseIdx, pvtRegionIndex);
Scalar factor = 1.0;
Scalar X = (rs - rssat * sg) / (rssat * ( 1.0 - sg));
Scalar omega = 0.0;
const Scalar pCap = Opm::abs(pg - p);
if ((rs >= (rssat * sg)) || (pCap < 1e-12)){
if(X > Psi){
factor = 0.0;
if ((rs >= (rssat * sg)) || (pCap < 1e-12)) {
if (X > Psi) {
factor = 0.0;
omega = omegainn;
}
} else {
factor /= Xhi;
deltaDensity = (saturatedDensity - co2Density);
}
} else {
factor /= Xhi;
deltaDensity = (saturatedDensity - co2Density);
}
convectiveDrs_[compressedDofIdx]
= factor * permz * rssat * max(0.0, deltaDensity) * gravity / ( std::max(sg_max - sg, 0.0) * visc * distZ * poro) + (omega/Xhi);
convectiveDrs_[compressedDofIdx] =
factor * permz * rssat * max(Scalar{0.0}, deltaDensity) *
gravity / ( std::max(sg_max - sg, Scalar{0.0}) *
visc * distZ * poro) + (omega/Xhi);
}
template class MixingRateControls<BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>>;
#define INSTANTIATE_TYPE(T) \
template class MixingRateControls<BlackOilFluidSystem<T,BlackOilDefaultIndexTraits>>;
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace Opm

31
opm/simulators/flow/RSTConv.cpp
View File

@ -113,19 +113,26 @@ void RSTConv::gatherAndAccumulate(const std::vector<int>& lIdx,
}
}
template<std::size_t Size>
using BFV = Dune::BlockVector<Dune::FieldVector<double,Size>>;
template<class Scalar, std::size_t Size>
using BFV = Dune::BlockVector<Dune::FieldVector<Scalar,Size>>;
#define INSTANCE(SIZE) \
template void RSTConv::update<BFV<SIZE>>(const BFV<SIZE>&); \
template void RSTConv::gatherAndAccumulate<BFV<SIZE>>(const std::vector<int>&, \
const BFV<SIZE>&, int);
#define INSTANTIATE(T,SIZE) \
template void RSTConv::update(const BFV<T,SIZE>&); \
template void RSTConv::gatherAndAccumulate(const std::vector<int>&, \
const BFV<T,SIZE>&, int);
INSTANCE(1)
INSTANCE(2)
INSTANCE(3)
INSTANCE(4)
INSTANCE(5)
INSTANCE(6)
#define INSTANTIATE_TYPE(T) \
INSTANTIATE(T,1) \
INSTANTIATE(T,2) \
INSTANTIATE(T,3) \
INSTANTIATE(T,4) \
INSTANTIATE(T,5) \
INSTANTIATE(T,6)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace Opm

11
opm/simulators/flow/SolutionContainers.cpp
View File

@ -80,7 +80,14 @@ operator==(const MICPSolutionContainer<Scalar>& rhs) const
this->calciteConcentration == rhs.calciteConcentration;
}
template struct PolymerSolutionContainer<double>;
template struct MICPSolutionContainer<double>;
#define INSTANTIATE_TYPE(T) \
template struct PolymerSolutionContainer<T>; \
template struct MICPSolutionContainer<T>;
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace Opm

86
opm/simulators/flow/Transmissibility.cpp
View File

@ -38,43 +38,71 @@
namespace Opm {
template class Transmissibility<Dune::CpGrid,
Dune::GridView<Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>,
Dune::MultipleCodimMultipleGeomTypeMapper<Dune::GridView<Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>>,
Dune::CartesianIndexMapper<Dune::CpGrid>,
double>;
#define INSTANTIATE_TYPE(T) \
template class Transmissibility<Dune::CpGrid, \
Dune::GridView< \
Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>, \
Dune::MultipleCodimMultipleGeomTypeMapper< \
Dune::GridView< \
Dune::DefaultLeafGridViewTraits<Dune::CpGrid>>>, \
Dune::CartesianIndexMapper<Dune::CpGrid>, \
T>;
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
#ifdef HAVE_DUNE_FEM
#if DUNE_VERSION_GTE(DUNE_FEM, 2, 9)
using GV = Dune::Fem::AdaptiveLeafGridPart<Dune::CpGrid,
(Dune::PartitionIteratorType)4,
false>;
template class Transmissibility<Dune::CpGrid,
GV,
Dune::MultipleCodimMultipleGeomTypeMapper<GV>,
Dune::CartesianIndexMapper<Dune::CpGrid>,
double>;
#define INSTANTIATE_FEM_TYPE(T) \
template class Transmissibility<Dune::CpGrid, \
GV, \
Dune::MultipleCodimMultipleGeomTypeMapper<GV>, \
Dune::CartesianIndexMapper<Dune::CpGrid>, \
T>;
#else
template class Transmissibility<Dune::CpGrid,
Dune::GridView<Dune::Fem::GridPart2GridViewTraits<Dune::Fem::AdaptiveLeafGridPart<Dune::CpGrid, Dune::PartitionIteratorType(4), false>>>,
Dune::MultipleCodimMultipleGeomTypeMapper<Dune::GridView<Dune::Fem::GridPart2GridViewTraits<Dune::Fem::AdaptiveLeafGridPart<Dune::CpGrid, Dune::PartitionIteratorType(4), false>>>>,
Dune::CartesianIndexMapper<Dune::CpGrid>,
double>;
template class Transmissibility<Dune::CpGrid,
Dune::Fem::GridPart2GridViewImpl<
Dune::Fem::AdaptiveLeafGridPart<
Dune::CpGrid,
Dune::PartitionIteratorType(4),
false> >,
Dune::MultipleCodimMultipleGeomTypeMapper<
Dune::Fem::GridPart2GridViewImpl<
Dune::Fem::AdaptiveLeafGridPart<
Dune::CpGrid,
Dune::PartitionIteratorType(4),
false> > >,
Dune::CartesianIndexMapper<Dune::CpGrid>,
double>;
#define INSTANTIATE_FEM_TYPE(T) \
template class Transmissibility<Dune::CpGrid, \
Dune::GridView< \
Dune::Fem::GridPart2GridViewTraits< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), false>>>, \
Dune::MultipleCodimMultipleGeomTypeMapper< \
Dune::GridView< \
Dune::Fem::GridPart2GridViewTraits< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), false>>>>, \
Dune::CartesianIndexMapper<Dune::CpGrid>, \
T>; \
template class Transmissibility<Dune::CpGrid, \
Dune::Fem::GridPart2GridViewImpl< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), \
false> >, \
Dune::MultipleCodimMultipleGeomTypeMapper< \
Dune::Fem::GridPart2GridViewImpl< \
Dune::Fem::AdaptiveLeafGridPart< \
Dune::CpGrid, \
Dune::PartitionIteratorType(4), \
false> > >, \
Dune::CartesianIndexMapper<Dune::CpGrid>, \
T>;
#endif
INSTANTIATE_FEM_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_FEM_TYPE(float)
#endif
#endif // HAVE_DUNE_FEM
} // namespace Opm

58
opm/simulators/linalg/MILU.cpp
View File

@ -255,45 +255,41 @@ void milun_decomposition(const M& A, int n, MILU_VARIANT milu, M& ILU,
}
}
#define INSTANTIATE(T, ...) \
template void milu0_decomposition<__VA_ARGS__> \
(__VA_ARGS__&,std::function<T(const T&)>, std::function<T(const T&)>, \
std::vector<typename __VA_ARGS__::block_type>*);
template double Opm::detail::identityFunctor(const double&);
template double Opm::detail::oneFunctor(const double&);
template double Opm::detail::signFunctor(const double&);
template double Opm::detail::isPositiveFunctor(const double&);
template double Opm::detail::absFunctor(const double&);
#define INSTANCE(...) \
template void milu0_decomposition<__VA_ARGS__> \
(__VA_ARGS__&,std::function<double(const double&)>, std::function<double(const double&)>, \
std::vector<typename __VA_ARGS__::block_type>*);
#define INSTANCE_ILUN(...) \
#define INSTANTIATE_ILUN(...) \
template void milun_decomposition(const __VA_ARGS__&, int, MILU_VARIANT, \
__VA_ARGS__&,Reorderer&,Reorderer&);
#define INSTANCE_FULL(...) \
INSTANCE(__VA_ARGS__) \
INSTANCE_ILUN(__VA_ARGS__)
#define INSTANTIATE_FULL(T,...) \
INSTANTIATE(T,__VA_ARGS__) \
INSTANTIATE_ILUN(__VA_ARGS__)
#define INSTANCE_BLOCK(Dim) \
INSTANCE_FULL(Dune::BCRSMatrix<MatrixBlock<double,Dim,Dim>>)
#define INSTANTIATE_DIM(T,Dim) \
INSTANTIATE_FULL(T,Dune::BCRSMatrix<MatrixBlock<T,Dim,Dim>>) \
INSTANTIATE_FULL(T,Dune::BCRSMatrix<Dune::FieldMatrix<T,Dim,Dim>>)
#define INSTANCE_FM(Dim) \
INSTANCE_FULL(Dune::BCRSMatrix<Dune::FieldMatrix<double,Dim,Dim>>)
#define INSTANTIATE_TYPE(T) \
template T identityFunctor(const T&); \
template T oneFunctor(const T&); \
template T signFunctor(const T&); \
template T isPositiveFunctor(const T&); \
template T absFunctor(const T&); \
INSTANTIATE_DIM(T,1) \
INSTANTIATE_DIM(T,2) \
INSTANTIATE_DIM(T,3) \
INSTANTIATE_DIM(T,4) \
INSTANTIATE_DIM(T,5) \
INSTANTIATE_DIM(T,6)
INSTANCE_FM(1)
INSTANCE_FM(2)
INSTANCE_FM(3)
INSTANCE_FM(4)
INSTANCE_FM(5)
INSTANCE_FM(6)
INSTANTIATE_TYPE(double)
INSTANCE_BLOCK(1)
INSTANCE_BLOCK(2)
INSTANCE_BLOCK(3)
INSTANCE_BLOCK(4)
INSTANCE_BLOCK(5)
INSTANCE_BLOCK(6)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // end namespace detail

45
opm/simulators/linalg/ParallelOverlappingILU0.cpp
View File

@ -27,30 +27,37 @@
namespace Opm
{
#define INSTANCE_PAR(Dim, ...) \
template class ParallelOverlappingILU0<Dune::BCRSMatrix<MatrixBlock<double,Dim,Dim>>, \
Dune::BlockVector<Dune::FieldVector<double,Dim>>, \
Dune::BlockVector<Dune::FieldVector<double,Dim>>, \
__VA_ARGS__>; \
template class ParallelOverlappingILU0<Dune::BCRSMatrix<Dune::FieldMatrix<double,Dim,Dim>>, \
Dune::BlockVector<Dune::FieldVector<double,Dim>>, \
Dune::BlockVector<Dune::FieldVector<double,Dim>>, \
#define INSTANTIATE_PAR(T, Dim, ...) \
template class ParallelOverlappingILU0<Dune::BCRSMatrix<MatrixBlock<T,Dim,Dim>>, \
Dune::BlockVector<Dune::FieldVector<T,Dim>>, \
Dune::BlockVector<Dune::FieldVector<T,Dim>>, \
__VA_ARGS__>; \
template class ParallelOverlappingILU0<Dune::BCRSMatrix<Dune::FieldMatrix<T,Dim,Dim>>, \
Dune::BlockVector<Dune::FieldVector<T,Dim>>, \
Dune::BlockVector<Dune::FieldVector<T,Dim>>, \
__VA_ARGS__>;
#if HAVE_MPI
#define INSTANCE(Dim) \
INSTANCE_PAR(Dim, Dune::Amg::SequentialInformation) \
INSTANCE_PAR(Dim, Dune::OwnerOverlapCopyCommunication<int,int>)
#define INSTANTIATE(T,Dim) \
INSTANTIATE_PAR(T, Dim, Dune::Amg::SequentialInformation) \
INSTANTIATE_PAR(T, Dim, Dune::OwnerOverlapCopyCommunication<int,int>)
#else
#define INSTANCE(Dim) \
INSTANCE_PAR(Dim, Dune::Amg::SequentialInformation)
#define INSTANTIATE(T,Dim) \
INSTANTIATE_PAR(T, Dim, Dune::Amg::SequentialInformation)
#endif
INSTANCE(1)
INSTANCE(2)
INSTANCE(3)
INSTANCE(4)
INSTANCE(5)
INSTANCE(6)
#define INSTANTIATE_TYPE(T) \
INSTANTIATE(T,1) \
INSTANTIATE(T,2) \
INSTANTIATE(T,3) \
INSTANTIATE(T,4) \
INSTANTIATE(T,5) \
INSTANTIATE(T,6)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // end namespace Opm

3
opm/simulators/linalg/PropertyTree.cpp
View File

@ -100,6 +100,8 @@ template std::string PropertyTree::get<std::string>(const std::string& key) cons
template std::string PropertyTree::get<std::string>(const std::string& key, const std::string& defValue) const;
template double PropertyTree::get<double>(const std::string& key) const;
template double PropertyTree::get<double>(const std::string& key, const double& defValue) const;
template float PropertyTree::get<float>(const std::string& key) const;
template float PropertyTree::get<float>(const std::string& key, const float& defValue) const;
template int PropertyTree::get<int>(const std::string& key) const;
template int PropertyTree::get<int>(const std::string& key, const int& defValue) const;
template size_t PropertyTree::get<size_t>(const std::string& key) const;
@ -108,6 +110,7 @@ template bool PropertyTree::get<bool>(const std::string& key) const;
template bool PropertyTree::get<bool>(const std::string& key, const bool& defValue) const;
template void PropertyTree::put<std::string>(const std::string& key, const std::string& value);
template void PropertyTree::put<float>(const std::string& key, const float& value);
template void PropertyTree::put<double>(const std::string& key, const double& value);
template void PropertyTree::put<int>(const std::string& key, const int& value);

4
opm/simulators/timestepping/EclTimeSteppingParams.cpp
View File

@ -53,4 +53,8 @@ void registerEclTimeSteppingParameters()
template void registerEclTimeSteppingParameters<double>();
#if FLOW_INSTANTIATE_FLOAT
template void registerEclTimeSteppingParameters<float>();
#endif
} // namespace Opm

62
opm/simulators/utils/ComponentName.cpp
View File

@ -86,37 +86,41 @@ ComponentName<FluidSystem,Indices>::ComponentName()
}
}
#define INSTANCE( ...) \
template class ComponentName<BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>, \
__VA_ARGS__>;
template<class Scalar>
using FS = BlackOilFluidSystem<Scalar,BlackOilDefaultIndexTraits>;
// One phase
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>)
#define INSTANTIATE(T,...) \
template class ComponentName<FS<T>, __VA_ARGS__>;
// Two phase
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>)
#define INSTANTIATE_TYPE(T) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
// Blackoil
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace Opm

4
opm/simulators/wells/ALQState.cpp
View File

@ -180,4 +180,8 @@ bool ALQState<Scalar>::operator==(const ALQState& rhs) const
template class ALQState<double>;
#if FLOW_INSTANTIATE_FLOAT
template class ALQState<float>;
#endif
}

4
opm/simulators/wells/BlackoilWellModelConstraints.cpp
View File

@ -633,4 +633,8 @@ updateGroupIndividualControl(const Group& group,
template class BlackoilWellModelConstraints<double>;
#if FLOW_INSTANTIATE_FLOAT
template class BlackoilWellModelConstraints<float>;
#endif
}

4
opm/simulators/wells/BlackoilWellModelGuideRates.cpp
View File

@ -604,4 +604,8 @@ guideRateUpdateIsNeeded(const int reportStepIdx) const
template class BlackoilWellModelGuideRates<double>;
#if FLOW_INSTANTIATE_FLOAT
template class BlackoilWellModelGuideRates<float>;
#endif
} // namespace Opm

4
opm/simulators/wells/ConnFiltrateData.cpp
View File

@ -70,4 +70,8 @@ bool ConnFiltrateData<Scalar>::operator==(const ConnFiltrateData& rhs) const
template struct ConnFiltrateData<double>;
#if FLOW_INSTANTIATE_FLOAT
template struct ConnFiltrateData<float>;
#endif
}

4
opm/simulators/wells/FractionCalculator.cpp
View File

@ -193,4 +193,8 @@ getGroupRateVector(const std::string& group_name)
template class FractionCalculator<double>;
#if FLOW_INSTANTIATE_FLOAT
template class FractionCalculator<float>;
#endif
} // namespace Opm::WGHelpers

4
opm/simulators/wells/GasLiftCommon.cpp
View File

@ -105,4 +105,8 @@ logMessage_(const std::string& prefix,
template class GasLiftCommon<double>;
#if FLOW_INSTANTIATE_FLOAT
template class GasLiftCommon<float>;
#endif
} // namespace Opm

4
opm/simulators/wells/GasLiftGroupInfo.cpp
View File

@ -740,4 +740,8 @@ updateGroupIdxMap_(const std::string& group_name)
template class GasLiftGroupInfo<double>;
#if FLOW_INSTANTIATE_FLOAT
template class GasLiftGroupInfo<float>;
#endif
} // namespace Opm

4
opm/simulators/wells/GasLiftSingleWellGeneric.cpp
View File

@ -1890,4 +1890,8 @@ BasicRates(const LimitedRates& rates)
template class GasLiftSingleWellGeneric<double>;
#if FLOW_INSTANTIATE_FLOAT
template class GasLiftSingleWellGeneric<float>;
#endif
} // namespace Opm

4
opm/simulators/wells/GasLiftStage2.cpp
View File

@ -1150,4 +1150,8 @@ updateRates(const std::array<Scalar, 4>& delta)
template class GasLiftStage2<double>;
#if FLOW_INSTANTIATE_FLOAT
template class GasLiftStage2<float>;
#endif
} // namespace Opm

7
opm/simulators/wells/GroupEconomicLimitsChecker.cpp
View File

@ -400,10 +400,15 @@ template<class Scalar>
void GroupEconomicLimitsChecker<Scalar>::
throwNotImplementedError(const std::string& error) const
{
const std::string msg = fmt::format("Group: {} : GECON : {} not implemented", this->group_.name(), error);
const std::string msg = fmt::format("Group: {} : GECON : {} not implemented",
this->group_.name(), error);
OPM_DEFLOG_THROW(std::runtime_error, msg, this->deferred_logger_);
}
template class GroupEconomicLimitsChecker<double>;
#if FLOW_INSTANTIATE_FLOAT
template class GroupEconomicLimitsChecker<float>;
#endif
} // namespace Opm

4
opm/simulators/wells/GroupState.cpp
View File

@ -421,4 +421,8 @@ has_gpmaint_target(const std::string& gname) const
template class GroupState<double>;
#if FLOW_INSTANTIATE_FLOAT
template class GroupState<float>;
#endif
}

66
opm/simulators/wells/MultisegmentWellAssemble.cpp
View File

@ -376,37 +376,43 @@ assemblePerforationEq(const int seg,
}
}
#define INSTANCE(...) \
template class MultisegmentWellAssemble<BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>,__VA_ARGS__>;
template<class Scalar>
using FS = BlackOilFluidSystem<Scalar,BlackOilDefaultIndexTraits>;
// One phase
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>)
#define INSTANTIATE(T,...) \
template class MultisegmentWellAssemble<FS<T>,__VA_ARGS__>;
// Two phase
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>)
#define INSTANTIATE_TYPE(T) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,false,1u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,true,2u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
// Blackoil
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,false,1u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,true,2u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
}

4
opm/simulators/wells/MultisegmentWellGeneric.cpp
View File

@ -200,4 +200,8 @@ MultisegmentWellGeneric<Scalar>::getSegmentDp(const int seg,
template class MultisegmentWellGeneric<double>;
#if FLOW_INSTANTIATE_FLOAT
template class MultisegmentWellGeneric<float>;
#endif
} // namespace Opm

65
opm/simulators/wells/MultisegmentWellPrimaryVariables.cpp
View File

@ -652,38 +652,43 @@ outputLowLimitPressureSegments(DeferredLogger& deferred_logger) const
}
}
#define INSTANCE(...) \
template class MultisegmentWellPrimaryVariables<BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>,__VA_ARGS__>;
template<class Scalar>
using FS = BlackOilFluidSystem<Scalar,BlackOilDefaultIndexTraits>;
// One phase
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>)
#define INSTANTIATE(T,...) \
template class MultisegmentWellPrimaryVariables<FS<T>,__VA_ARGS__>;
// Two phase
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>)
#define INSTANTIATE_TYPE(T) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,false,1u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,true,2u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
// Blackoil
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,false,1u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,true,2u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
}

63
opm/simulators/wells/ParallelWellInfo.cpp
View File

@ -256,7 +256,7 @@ int CommunicateAboveBelow<Scalar>::endReset()
using FromSet = Dune::EnumItem<Attribute,owner>;
using ToSet = Dune::AllSet<Attribute>;
interface_.build(remote_indices_, FromSet(), ToSet());
communicator_.build<double*>(interface_);
communicator_.build<Scalar*>(interface_);
}
#endif
return num_local_perfs_;
@ -549,9 +549,6 @@ T ParallelWellInfo<Scalar>::broadcastFirstPerforationValue(const T& t) const
return res;
}
template int ParallelWellInfo<double>::broadcastFirstPerforationValue<int>(const int&) const;
template double ParallelWellInfo<double>::broadcastFirstPerforationValue<double>(const double&) const;
template<class Scalar>
std::vector<Scalar> ParallelWellInfo<Scalar>::
communicateAboveValues(Scalar zero_value,
@ -713,26 +710,44 @@ checkAllConnectionsFound()
template<class Scalar> using dIter = typename std::vector<Scalar>::iterator;
template<class Scalar> using cdIter = typename std::vector<Scalar>::const_iterator;
#define INSTANCE(T) \
template class CheckDistributedWellConnections<T>; \
template class CommunicateAboveBelow<T>; \
template class GlobalPerfContainerFactory<T>; \
template class ParallelWellInfo<T>; \
template typename cdIter<T>::value_type \
ParallelWellInfo<T>::sumPerfValues<cdIter<T>>(cdIter<T>,cdIter<T>) const; \
template typename dIter<T>::value_type \
ParallelWellInfo<T>::sumPerfValues<dIter<T>>(dIter<T>,dIter<T>) const; \
template void CommunicateAboveBelow<T>::partialSumPerfValues<dIter<T>>(dIter<T>, dIter<T>) const; \
template bool operator<(const ParallelWellInfo<T>&, const ParallelWellInfo<T>&); \
template bool operator<(const ParallelWellInfo<T>&, const std::pair<std::string, bool>&); \
template bool operator<(const std::pair<std::string, bool>&, const ParallelWellInfo<T>&); \
template bool operator==(const ParallelWellInfo<T>&, const ParallelWellInfo<T>&); \
template bool operator==(const ParallelWellInfo<T>& well, const std::pair<std::string, bool>&); \
template bool operator==(const std::pair<std::string, bool>&, const ParallelWellInfo<T>&); \
template bool operator!=(const ParallelWellInfo<T>&, const ParallelWellInfo<T>&); \
template bool operator!=(const std::pair<std::string, bool>&, const ParallelWellInfo<T>&); \
template bool operator!=(const ParallelWellInfo<T>&, const std::pair<std::string, bool>&);
#define INSTANTIATE_TYPE(T) \
template class CheckDistributedWellConnections<T>; \
template class CommunicateAboveBelow<T>; \
template class GlobalPerfContainerFactory<T>; \
template class ParallelWellInfo<T>; \
template typename cdIter<T>::value_type \
ParallelWellInfo<T>::sumPerfValues<cdIter<T>>(cdIter<T>,cdIter<T>) const; \
template typename dIter<T>::value_type \
ParallelWellInfo<T>::sumPerfValues<dIter<T>>(dIter<T>,dIter<T>) const; \
template int ParallelWellInfo<T>:: \
broadcastFirstPerforationValue<int>(const int&) const; \
template T ParallelWellInfo<T>:: \
broadcastFirstPerforationValue<T>(const T&) const; \
template void CommunicateAboveBelow<T>:: \
partialSumPerfValues<dIter<T>>(dIter<T>, dIter<T>) const; \
template bool operator<(const ParallelWellInfo<T>&, \
const ParallelWellInfo<T>&); \
template bool operator<(const ParallelWellInfo<T>&, \
const std::pair<std::string, bool>&); \
template bool operator<(const std::pair<std::string, bool>&, \
const ParallelWellInfo<T>&); \
template bool operator==(const ParallelWellInfo<T>&, \
const ParallelWellInfo<T>&); \
template bool operator==(const ParallelWellInfo<T>& well, \
const std::pair<std::string, bool>&); \
template bool operator==(const std::pair<std::string, bool>&, \
const ParallelWellInfo<T>&); \
template bool operator!=(const ParallelWellInfo<T>&, \
const ParallelWellInfo<T>&); \
template bool operator!=(const std::pair<std::string, bool>&, \
const ParallelWellInfo<T>&); \
template bool operator!=(const ParallelWellInfo<T>&, \
const std::pair<std::string, bool>&);
INSTANCE(double)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // end namespace Opm

4
opm/simulators/wells/PerfData.cpp
View File

@ -157,4 +157,8 @@ bool PerfData<Scalar>::operator==(const PerfData& rhs) const
template class PerfData<double>;
#if FLOW_INSTANTIATE_FLOAT
template class PerfData<float>;
#endif
} // namespace Opm

96
opm/simulators/wells/RateConverter.cpp
View File

@ -369,52 +369,62 @@ inferDissolvedVaporisedRatio(const Scalar rsMax,
return dissolvedVaporisedRatio(io, ig, rsMax, rvMax, surface_rates);
}
using FS = BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>;
template void SurfaceToReservoirVoidage<FS,std::vector<int>>::
sumRates(std::unordered_map<int,Attributes>&,
std::unordered_map<int,Attributes>&,
Parallel::Communication);
template<class Scalar>
using FS = BlackOilFluidSystem<Scalar,BlackOilDefaultIndexTraits>;
template void SurfaceToReservoirVoidage<FS,std::vector<int>>::
calcInjCoeff<std::vector<double>>(const int, const int, std::vector<double>&) const;
template void SurfaceToReservoirVoidage<FS,std::vector<int>>::
calcCoeff<std::vector<double>>(const int, const int, std::vector<double>&) const;
template void SurfaceToReservoirVoidage<FS,std::vector<int>>::
calcCoeff<std::vector<double>, std::vector<double>>(const int, const int, const std::vector<double>&, std::vector<double>&) const;
template void SurfaceToReservoirVoidage<FS,std::vector<int>>::
calcReservoirVoidageRates<std::vector<double>,std::vector<double>>(const int,
const double,
const double,
const double,
const double,
const double,
const double,
const double,
const std::vector<double>&,
std::vector<double>&) const;
template void SurfaceToReservoirVoidage<FS,std::vector<int>>::
calcReservoirVoidageRates<double const*,double*>(const int,
const double,
const double,
const double,
const double,
const double,
const double,
const double,
double const* const&,
double*&) const;
#define INSTANTIATE_TYPE(T) \
template void SurfaceToReservoirVoidage<FS<T>,std::vector<int>>:: \
sumRates(std::unordered_map<int,Attributes>&, \
std::unordered_map<int,Attributes>&, \
Parallel::Communication); \
template void SurfaceToReservoirVoidage<FS<T>,std::vector<int>>:: \
calcInjCoeff(const int, const int, \
std::vector<T>&) const; \
template void SurfaceToReservoirVoidage<FS<T>,std::vector<int>>:: \
calcCoeff(const int, const int, std::vector<T>&) const; \
template void SurfaceToReservoirVoidage<FS<T>,std::vector<int>>:: \
calcCoeff(const int, \
const int, \
const std::vector<T>&, \
std::vector<T>&) const; \
template void SurfaceToReservoirVoidage<FS<T>,std::vector<int>>:: \
calcReservoirVoidageRates(const int, \
const T, \
const T, \
const T, \
const T, \
const T, \
const T, \
const T, \
const std::vector<T>&, \
std::vector<T>&) const; \
template void SurfaceToReservoirVoidage<FS<T>,std::vector<int>>:: \
calcReservoirVoidageRates(const int, \
const T, \
const T, \
const T, \
const T, \
const T, \
const T, \
const T, \
T const* const&, \
T*&) const; \
template void SurfaceToReservoirVoidage<FS<T>,std::vector<int>>:: \
calcReservoirVoidageRates(const int, \
const int, \
const std::vector<T>&, \
std::vector<T>&) const; \
template std::pair<T,T> \
SurfaceToReservoirVoidage<FS<T>,std::vector<int>>:: \
inferDissolvedVaporisedRatio(const T, \
const T, \
const std::vector<T>::iterator&) const;
template void SurfaceToReservoirVoidage<FS,std::vector<int>>::
calcReservoirVoidageRates<std::vector<double>>(const int,
const int,
const std::vector<double>&,
std::vector<double>&) const;
INSTANTIATE_TYPE(double)
template std::pair<double,double>
SurfaceToReservoirVoidage<FS,std::vector<int>>::
inferDissolvedVaporisedRatio<std::vector<double>::iterator>(const double,
const double,
const std::vector<double>::iterator&) const;
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace RateConverter
} // namespace Opm

4
opm/simulators/wells/SegmentState.cpp
View File

@ -149,4 +149,8 @@ bool SegmentState<Scalar>::operator==(const SegmentState& rhs) const
template class SegmentState<double>;
#if FLOW_INSTANTIATE_FLOAT
template class SegmentState<float>;
#endif
} // namespace Opm

4
opm/simulators/wells/SingleWellState.cpp
View File

@ -360,4 +360,8 @@ bool SingleWellState<Scalar>::operator==(const SingleWellState& rhs) const
template class SingleWellState<double>;
#if FLOW_INSTANTIATE_FLOAT
template class SingleWellState<float>;
#endif
}

66
opm/simulators/wells/StandardWellAssemble.cpp
View File

@ -257,37 +257,43 @@ assembleZFracEq(const EvalWell& cq_s_zfrac_effective,
}
}
#define INSTANCE(Dim,...) \
template class StandardWellAssemble<BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>,__VA_ARGS__>;
template<class Scalar>
using FS = BlackOilFluidSystem<Scalar,BlackOilDefaultIndexTraits>;
// One phase
INSTANCE(4u, BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(5u, BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(9u, BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>)
#define INSTANTIATE(T,...) \
template class StandardWellAssemble<FS<T>,__VA_ARGS__>;
// Two phase
INSTANCE(6u, BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>)
INSTANCE(6u, BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(6u, BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>)
INSTANCE(7u, BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>)
INSTANCE(7u, BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,true,0u,2u,0u>)
INSTANCE(7u, BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(7u, BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>)
INSTANCE(7u, BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>)
INSTANCE(8u, BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>)
INSTANCE(7u, BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>)
INSTANCE(8u, BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>)
INSTANCE(7u, BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>)
// Blackoil
INSTANCE(8u, BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(9u, BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>)
INSTANCE(9u, BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>)
INSTANCE(9u, BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>)
INSTANCE(9u, BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>)
INSTANCE(9u, BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>)
INSTANCE(10u, BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(10u, BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>)
INSTANCE(10u, BlackOilIndices<0u,0u,0u,1u,false,false,1u,0u>)
INSTANCE(11u, BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
#define INSTANTIATE_TYPE(T) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,1u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
}

66
opm/simulators/wells/StandardWellConnections.cpp
View File

@ -666,39 +666,43 @@ connectionRatezFraction(Scalar& rate,
return {well_.restrictEval(cq_s_zfrac_effective), cq_s_zfrac_effective};
}
#define INSTANCE(...) \
template class StandardWellConnections<BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>, \
__VA_ARGS__>;
template<class Scalar>
using FS = BlackOilFluidSystem<Scalar,BlackOilDefaultIndexTraits>;
// One phase
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>)
#define INSTANTIATE(T,...) \
template class StandardWellConnections<FS<T>, __VA_ARGS__>;
// Two phase
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,true,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>)
#define INSTANTIATE_TYPE(T) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,1u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
// Blackoil
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,false,1u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
}

65
opm/simulators/wells/StandardWellPrimaryVariables.cpp
View File

@ -727,38 +727,43 @@ checkFinite(DeferredLogger& deferred_logger) const
}
}
#define INSTANCE(...) \
template class StandardWellPrimaryVariables<BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>,__VA_ARGS__>;
template<class Scalar>
using FS = BlackOilFluidSystem<Scalar,BlackOilDefaultIndexTraits>;
// One phase
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>)
#define INSTANTIATE(T,...) \
template class StandardWellPrimaryVariables<FS<T>,__VA_ARGS__>;
// Two phase
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,true,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>)
// Blackoil
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,false,1u,0u>)
#define INSTANTIATE_TYPE(T) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,1u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
}

49
opm/simulators/wells/TargetCalculator.cpp
View File

@ -266,28 +266,35 @@ InjectionTargetCalculator<Scalar>::guideTargetMode() const
return target_;
}
#define INSTANCE_TARGET_CALCULATOR(...) \
template __VA_ARGS__ TargetCalculator<double>::calcModeRateFromRates<__VA_ARGS__>(const __VA_ARGS__* rates) const;
#define INSTANTIATE_TARGET_CALCULATOR(T,...) \
template __VA_ARGS__ \
TargetCalculator<T>::calcModeRateFromRates(const __VA_ARGS__* rates) const;
template class TargetCalculator<double>;
template class InjectionTargetCalculator<double>;
#define INSTANTIATE_TYPE(T) \
template class TargetCalculator<T>; \
template class InjectionTargetCalculator<T>; \
INSTANTIATE_TARGET_CALCULATOR(T,T) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,3,0>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,4,0>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,5,0>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,6,0>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,7,0>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,8,0>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,9,0>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,10,0>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,-1,4>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,-1,5>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,-1,6>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,-1,7>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,-1,8>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,-1,9>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,-1,10>) \
INSTANTIATE_TARGET_CALCULATOR(T,DenseAd::Evaluation<T,-1,11>)
INSTANCE_TARGET_CALCULATOR(double)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,3,0>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,4,0>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,5,0>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,6,0>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,7,0>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,8,0>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,9,0>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,10,0>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,-1,4>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,-1,5>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,-1,6>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,-1,7>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,-1,8>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,-1,9>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,-1,10>)
INSTANCE_TARGET_CALCULATOR(DenseAd::Evaluation<double,-1,11>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace Opm::WGHelpers

69
opm/simulators/wells/VFPHelpers.cpp
View File

@ -773,35 +773,56 @@ VFPInjTable::FLO_TYPE getType(const VFPInjTable& table)
return table.getFloType();
}
template const VFPInjTable& getTable<VFPInjTable>(const std::map<int, std::reference_wrapper<const VFPInjTable>>&, int);
template const VFPProdTable& getTable<VFPProdTable>(const std::map<int, std::reference_wrapper<const VFPProdTable>>&, int);
template const VFPInjTable&
getTable(const std::map<int, std::reference_wrapper<const VFPInjTable>>&, int);
template const VFPProdTable&
getTable(const std::map<int, std::reference_wrapper<const VFPProdTable>>&, int);
#define INSTANCE(...) \
template __VA_ARGS__ getFlo(const VFPInjTable&, const __VA_ARGS__&, const __VA_ARGS__&, const __VA_ARGS__&); \
template __VA_ARGS__ getFlo(const VFPProdTable&, const __VA_ARGS__&, const __VA_ARGS__&, const __VA_ARGS__&); \
template __VA_ARGS__ getGFR(const VFPProdTable&, const __VA_ARGS__&, const __VA_ARGS__&, const __VA_ARGS__&); \
template __VA_ARGS__ getWFR(const VFPProdTable&, const __VA_ARGS__&, const __VA_ARGS__&, const __VA_ARGS__&);
#define INSTANTIATE(...) \
template __VA_ARGS__ \
getFlo(const VFPInjTable&, const __VA_ARGS__&, \
const __VA_ARGS__&, const __VA_ARGS__&); \
template __VA_ARGS__ \
getFlo(const VFPProdTable&, const __VA_ARGS__&, \
const __VA_ARGS__&, const __VA_ARGS__&); \
template __VA_ARGS__ \
getGFR(const VFPProdTable&, const __VA_ARGS__&, \
const __VA_ARGS__&, const __VA_ARGS__&); \
template __VA_ARGS__ \
getWFR(const VFPProdTable&, const __VA_ARGS__&, \
const __VA_ARGS__&, const __VA_ARGS__&);
INSTANCE(double)
INSTANCE(DenseAd::Evaluation<double, -1, 4u>)
INSTANCE(DenseAd::Evaluation<double, -1, 5u>)
INSTANCE(DenseAd::Evaluation<double, -1, 6u>)
INSTANCE(DenseAd::Evaluation<double, -1, 7u>)
INSTANCE(DenseAd::Evaluation<double, -1, 8u>)
INSTANCE(DenseAd::Evaluation<double, -1, 9u>)
INSTANCE(DenseAd::Evaluation<double, -1, 10u>)
INSTANCE(DenseAd::Evaluation<double, -1, 11u>)
INSTANCE(DenseAd::Evaluation<double, 3, 0u>)
INSTANCE(DenseAd::Evaluation<double, 4, 0u>)
INSTANCE(DenseAd::Evaluation<double, 5, 0u>)
INSTANCE(DenseAd::Evaluation<double, 6, 0u>)
INSTANCE(DenseAd::Evaluation<double, 7, 0u>)
INSTANCE(DenseAd::Evaluation<double, 8, 0u>)
INSTANCE(DenseAd::Evaluation<double, 9, 0u>)
INSTANCE(DenseAd::Evaluation<double, 10, 0u>)
#define INSTANTIATE_TYPE(T) \
INSTANTIATE(T) \
INSTANTIATE(DenseAd::Evaluation<T, -1, 4u>) \
INSTANTIATE(DenseAd::Evaluation<T, -1, 5u>) \
INSTANTIATE(DenseAd::Evaluation<T, -1, 6u>) \
INSTANTIATE(DenseAd::Evaluation<T, -1, 7u>) \
INSTANTIATE(DenseAd::Evaluation<T, -1, 8u>) \
INSTANTIATE(DenseAd::Evaluation<T, -1, 9u>) \
INSTANTIATE(DenseAd::Evaluation<T, -1, 10u>) \
INSTANTIATE(DenseAd::Evaluation<T, -1, 11u>) \
INSTANTIATE(DenseAd::Evaluation<T, 3, 0u>) \
INSTANTIATE(DenseAd::Evaluation<T, 4, 0u>) \
INSTANTIATE(DenseAd::Evaluation<T, 5, 0u>) \
INSTANTIATE(DenseAd::Evaluation<T, 6, 0u>) \
INSTANTIATE(DenseAd::Evaluation<T, 7, 0u>) \
INSTANTIATE(DenseAd::Evaluation<T, 8, 0u>) \
INSTANTIATE(DenseAd::Evaluation<T, 9, 0u>) \
INSTANTIATE(DenseAd::Evaluation<T, 10, 0u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace detail
template class VFPHelpers<double>;
#if FLOW_INSTANTIATE_FLOAT
template class VFPHelpers<float>;
#endif
} // namespace Opm

53
opm/simulators/wells/VFPInjProperties.cpp
View File

@ -125,30 +125,37 @@ EvalWell VFPInjProperties<Scalar>::bhp(const int table_id,
return bhp;
}
template class VFPInjProperties<double>;
#define INSTANTIATE(T,...) \
template __VA_ARGS__ \
VFPInjProperties<T>::bhp(const int, \
const __VA_ARGS__&, \
const __VA_ARGS__&, \
const __VA_ARGS__&, \
const T) const;
#define INSTANCE(...) \
template __VA_ARGS__ VFPInjProperties<double>::bhp<__VA_ARGS__>(const int, \
const __VA_ARGS__&, \
const __VA_ARGS__&, \
const __VA_ARGS__&, \
const double) const;
#define INSTANTIATE_TYPE(T) \
template class VFPInjProperties<T>; \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 4u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 5u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 6u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 7u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 8u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 9u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 10u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 11u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 3, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 4, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 5, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 6, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 7, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 8, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 9, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 10, 0u>)
INSTANCE(DenseAd::Evaluation<double, -1, 4u>)
INSTANCE(DenseAd::Evaluation<double, -1, 5u>)
INSTANCE(DenseAd::Evaluation<double, -1, 6u>)
INSTANCE(DenseAd::Evaluation<double, -1, 7u>)
INSTANCE(DenseAd::Evaluation<double, -1, 8u>)
INSTANCE(DenseAd::Evaluation<double, -1, 9u>)
INSTANCE(DenseAd::Evaluation<double, -1, 10u>)
INSTANCE(DenseAd::Evaluation<double, -1, 11u>)
INSTANCE(DenseAd::Evaluation<double, 3, 0u>)
INSTANCE(DenseAd::Evaluation<double, 4, 0u>)
INSTANCE(DenseAd::Evaluation<double, 5, 0u>)
INSTANCE(DenseAd::Evaluation<double, 6, 0u>)
INSTANCE(DenseAd::Evaluation<double, 7, 0u>)
INSTANCE(DenseAd::Evaluation<double, 8, 0u>)
INSTANCE(DenseAd::Evaluation<double, 9, 0u>)
INSTANCE(DenseAd::Evaluation<double, 10, 0u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} //Namespace Opm

61
opm/simulators/wells/VFPProdProperties.cpp
View File

@ -201,34 +201,41 @@ bhp(const int table_id,
return bhp;
}
template class VFPProdProperties<double>;
#define INSTANTIATE(T,...) \
template __VA_ARGS__ \
VFPProdProperties<T>::bhp(const int, \
const __VA_ARGS__&, \
const __VA_ARGS__&, \
const __VA_ARGS__&, \
const T , \
const T , \
const T , \
const T , \
const bool) const;
#define INSTANCE(...) \
template __VA_ARGS__ VFPProdProperties<double>::bhp<__VA_ARGS__>(const int, \
const __VA_ARGS__&, \
const __VA_ARGS__&, \
const __VA_ARGS__&, \
const double, \
const double, \
const double, \
const double, \
const bool) const;
#define INSTANTIATE_TYPE(T) \
template class VFPProdProperties<T>; \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 4u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 5u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 6u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 7u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 8u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 9u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 10u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, -1, 11u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 3, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 4, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 5, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 6, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 7, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 8, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 9, 0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T, 10, 0u>)
INSTANCE(DenseAd::Evaluation<double, -1, 4u>)
INSTANCE(DenseAd::Evaluation<double, -1, 5u>)
INSTANCE(DenseAd::Evaluation<double, -1, 6u>)
INSTANCE(DenseAd::Evaluation<double, -1, 7u>)
INSTANCE(DenseAd::Evaluation<double, -1, 8u>)
INSTANCE(DenseAd::Evaluation<double, -1, 9u>)
INSTANCE(DenseAd::Evaluation<double, -1, 10u>)
INSTANCE(DenseAd::Evaluation<double, -1, 11u>)
INSTANCE(DenseAd::Evaluation<double, 3, 0u>)
INSTANCE(DenseAd::Evaluation<double, 4, 0u>)
INSTANCE(DenseAd::Evaluation<double, 5, 0u>)
INSTANCE(DenseAd::Evaluation<double, 6, 0u>)
INSTANCE(DenseAd::Evaluation<double, 7, 0u>)
INSTANCE(DenseAd::Evaluation<double, 8, 0u>)
INSTANCE(DenseAd::Evaluation<double, 9, 0u>)
INSTANCE(DenseAd::Evaluation<double, 10, 0u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
}

4
opm/simulators/wells/WGState.cpp
View File

@ -63,4 +63,8 @@ bool WGState<Scalar>::operator==(const WGState& rhs) const
template struct WGState<double>;
#if FLOW_INSTANTIATE_FLOAT
template struct WGState<float>;
#endif
}

83
opm/simulators/wells/WellAssemble.cpp
View File

@ -283,48 +283,55 @@ assembleControlEqInj(const WellState<Scalar>& well_state,
}
}
#define INSTANCE_METHODS(A,...) \
template void WellAssemble<A>:: \
assembleControlEqProd<__VA_ARGS__>(const WellState<typename A::Scalar>&, \
#define INSTANTIATE_METHODS(A,...) \
template void WellAssemble<A>:: \
assembleControlEqProd<__VA_ARGS__>(const WellState<typename A::Scalar>&, \
const GroupState<typename A::Scalar>&, \
const Schedule&, \
const SummaryState&, \
const Well::ProductionControls&, \
const __VA_ARGS__&, \
const std::vector<__VA_ARGS__>&, \
const std::function<__VA_ARGS__()>&, \
__VA_ARGS__&, \
DeferredLogger&) const; \
template void WellAssemble<A>:: \
assembleControlEqInj<__VA_ARGS__>(const WellState<typename A::Scalar>&, \
const GroupState<typename A::Scalar>&, \
const Schedule&, \
const SummaryState&, \
const Well::InjectionControls&, \
const __VA_ARGS__&, \
const __VA_ARGS__&, \
const std::function<__VA_ARGS__()>&, \
__VA_ARGS__&, \
const Schedule&, \
const SummaryState&, \
const Well::ProductionControls&, \
const __VA_ARGS__&, \
const std::vector<__VA_ARGS__>&, \
const std::function<__VA_ARGS__()>&, \
__VA_ARGS__&, \
DeferredLogger&) const; \
template void WellAssemble<A>:: \
assembleControlEqInj<__VA_ARGS__>(const WellState<typename A::Scalar>&, \
const GroupState<typename A::Scalar>&, \
const Schedule&, \
const SummaryState&, \
const Well::InjectionControls&, \
const __VA_ARGS__&, \
const __VA_ARGS__&, \
const std::function<__VA_ARGS__()>&, \
__VA_ARGS__&, \
DeferredLogger&) const;
using FluidSys = BlackOilFluidSystem<double, BlackOilDefaultIndexTraits>;
template<class Scalar>
using FS = BlackOilFluidSystem<Scalar,BlackOilDefaultIndexTraits>;
template class WellAssemble<FluidSys>;
#define INSTANTIATE_TYPE(T) \
template class WellAssemble<FS<T>>; \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,3,0u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,4,0u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,5,0u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,6,0u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,7,0u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,8,0u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,9,0u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,-1,4u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,-1,5u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,-1,6u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,-1,7u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,-1,8u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,-1,9u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,-1,10u>) \
INSTANTIATE_METHODS(FS<T>, DenseAd::Evaluation<T,-1,11u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,3,0u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,4,0u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,5,0u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,6,0u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,7,0u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,8,0u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,9,0u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,-1,4u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,-1,5u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,-1,6u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,-1,7u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,-1,8u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,-1,9u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,-1,10u>)
INSTANCE_METHODS(FluidSys, DenseAd::Evaluation<double,-1,11u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace Opm

73
opm/simulators/wells/WellBhpThpCalculator.cpp
View File

@ -1009,11 +1009,11 @@ template<class Scalar>
bool
WellBhpThpCalculator<Scalar>::
bruteForceBracketCommonTHP(const std::function<Scalar(const Scalar)>& eq,
const std::array<Scalar, 2>& range,
Scalar& low, Scalar& high,
std::optional<Scalar>& approximate_solution,
const Scalar& limit,
DeferredLogger& deferred_logger)
const std::array<Scalar, 2>& range,
Scalar& low, Scalar& high,
std::optional<Scalar>& approximate_solution,
const Scalar& limit,
DeferredLogger& deferred_logger)
{
bool bracket_found = false;
low = range[0];
@ -1025,7 +1025,7 @@ bruteForceBracketCommonTHP(const std::function<Scalar(const Scalar)>& eq,
for (int i = 0; i < sample_number + 1; ++i) {
high = range[0] + interval * i;
eq_high = eq(high);
if ( (std::fabs(eq_high) < limit)) {
if ((std::fabs(eq_high) < limit)) {
approximate_solution = high;
break;
}
@ -1049,7 +1049,7 @@ template<class Scalar>
bool
WellBhpThpCalculator<Scalar>::
bruteForceBracketCommonTHP(const std::function<Scalar(const Scalar)>& eq,
Scalar& min_thp, Scalar& max_thp)
Scalar& min_thp, Scalar& max_thp)
{
bool bracket_found = false;
constexpr int sample_number = 1000;
@ -1069,33 +1069,40 @@ bruteForceBracketCommonTHP(const std::function<Scalar(const Scalar)>& eq,
return bracket_found;
}
template class WellBhpThpCalculator<double>;
#define INSTANTIATE(T,...) \
template __VA_ARGS__ \
WellBhpThpCalculator<T>:: \
calculateBhpFromThp(const WellState<T>&, \
const std::vector<__VA_ARGS__>&, \
const Well&, \
const SummaryState&, \
const T, \
DeferredLogger&) const;
#define INSTANCE(...) \
template __VA_ARGS__ WellBhpThpCalculator<double>:: \
calculateBhpFromThp<__VA_ARGS__>(const WellState<double>&, \
const std::vector<__VA_ARGS__>&, \
const Well&, \
const SummaryState&, \
const double, \
DeferredLogger&) const;
#define INSTANTIATE_TYPE(T) \
template class WellBhpThpCalculator<T>; \
INSTANTIATE(T,T) \
INSTANTIATE(T,DenseAd::Evaluation<T,3,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,4,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,5,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,6,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,7,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,8,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,9,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,10,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,4u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,5u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,6u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,7u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,8u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,9u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,10u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,11u>)
INSTANCE(double)
INSTANCE(DenseAd::Evaluation<double,3,0u>)
INSTANCE(DenseAd::Evaluation<double,4,0u>)
INSTANCE(DenseAd::Evaluation<double,5,0u>)
INSTANCE(DenseAd::Evaluation<double,6,0u>)
INSTANCE(DenseAd::Evaluation<double,7,0u>)
INSTANCE(DenseAd::Evaluation<double,8,0u>)
INSTANCE(DenseAd::Evaluation<double,9,0u>)
INSTANCE(DenseAd::Evaluation<double,10,0u>)
INSTANCE(DenseAd::Evaluation<double,-1,4u>)
INSTANCE(DenseAd::Evaluation<double,-1,5u>)
INSTANCE(DenseAd::Evaluation<double,-1,6u>)
INSTANCE(DenseAd::Evaluation<double,-1,7u>)
INSTANCE(DenseAd::Evaluation<double,-1,8u>)
INSTANCE(DenseAd::Evaluation<double,-1,9u>)
INSTANCE(DenseAd::Evaluation<double,-1,10u>)
INSTANCE(DenseAd::Evaluation<double,-1,11u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace Opm

4
opm/simulators/wells/WellConstraints.cpp
View File

@ -295,4 +295,8 @@ activeProductionConstraint(const SingleWellState<Scalar>& ws,
template class WellConstraints<double>;
#if FLOW_INSTANTIATE_FLOAT
template class WellConstraints<float>;
#endif
} // namespace Opm

4
opm/simulators/wells/WellConvergence.cpp
View File

@ -162,4 +162,8 @@ checkConvergencePolyMW(const std::vector<Scalar>& res,
template class WellConvergence<double>;
#if FLOW_INSTANTIATE_FLOAT
template class WellConvergence<float>;
#endif
}

4
opm/simulators/wells/WellFilterCake.cpp
View File

@ -142,4 +142,8 @@ updateInjFCMult(const WellInterfaceGeneric<Scalar>& well,
template class WellFilterCake<double>;
#if FLOW_INSTANTIATE_FLOAT
template class WellFilterCake<float>;
#endif
} // namespace Opm

4
opm/simulators/wells/WellGroupConstraints.cpp
View File

@ -205,4 +205,8 @@ checkGroupConstraints(WellState<Scalar>& well_state,
template class WellGroupConstraints<double>;
#if FLOW_INSTANTIATE_FLOAT
template class WellGroupConstraints<float>;
#endif
} // namespace Opm

92
opm/simulators/wells/WellGroupControls.cpp
View File

@ -549,50 +549,56 @@ getGroupProductionTargetRate(const Group& group,
return scale;
}
template class WellGroupControls<double>;
#define INSTANTIATE(T,...) \
template void WellGroupControls<T>:: \
getGroupInjectionControl(const Group&, \
const WellState<T>&, \
const GroupState<T>&, \
const Schedule&, \
const SummaryState&, \
const InjectorType&, \
const __VA_ARGS__& bhp, \
const __VA_ARGS__& injection_rate, \
const RateConvFunc& rateConverter, \
T efficiencyFactor, \
__VA_ARGS__& control_eq, \
DeferredLogger& deferred_logger) const; \
template void WellGroupControls<T>:: \
getGroupProductionControl(const Group&, \
const WellState<T>&, \
const GroupState<T>&, \
const Schedule&, \
const SummaryState&, \
const __VA_ARGS__& bhp, \
const std::vector<__VA_ARGS__>&, \
const RateConvFunc& rateConverter, \
T efficiencyFactor, \
__VA_ARGS__& control_eq, \
DeferredLogger& deferred_logger) const;
#define INSTANCE(...) \
template void WellGroupControls<double>:: \
getGroupInjectionControl<__VA_ARGS__>(const Group&, \
const WellState<double>&, \
const GroupState<double>&, \
const Schedule&, \
const SummaryState&, \
const InjectorType&, \
const __VA_ARGS__& bhp, \
const __VA_ARGS__& injection_rate, \
const RateConvFunc& rateConverter, \
double efficiencyFactor, \
__VA_ARGS__& control_eq, \
DeferredLogger& deferred_logger) const; \
template void WellGroupControls<double>:: \
getGroupProductionControl<__VA_ARGS__>(const Group&, \
const WellState<double>&, \
const GroupState<double>&, \
const Schedule&, \
const SummaryState&, \
const __VA_ARGS__& bhp, \
const std::vector<__VA_ARGS__>&, \
const RateConvFunc& rateConverter, \
double efficiencyFactor, \
__VA_ARGS__& control_eq, \
DeferredLogger& deferred_logger) const; \
#define INSTANTIATE_TYPE(T) \
template class WellGroupControls<T>; \
INSTANTIATE(T,DenseAd::Evaluation<T,3,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,4,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,5,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,6,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,7,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,8,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,9,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,10,0u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,4u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,5u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,6u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,7u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,8u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,9u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,10u>) \
INSTANTIATE(T,DenseAd::Evaluation<T,-1,11u>)
INSTANCE(DenseAd::Evaluation<double,3,0u>)
INSTANCE(DenseAd::Evaluation<double,4,0u>)
INSTANCE(DenseAd::Evaluation<double,5,0u>)
INSTANCE(DenseAd::Evaluation<double,6,0u>)
INSTANCE(DenseAd::Evaluation<double,7,0u>)
INSTANCE(DenseAd::Evaluation<double,8,0u>)
INSTANCE(DenseAd::Evaluation<double,9,0u>)
INSTANCE(DenseAd::Evaluation<double,10,0u>)
INSTANCE(DenseAd::Evaluation<double,-1,4u>)
INSTANCE(DenseAd::Evaluation<double,-1,5u>)
INSTANCE(DenseAd::Evaluation<double,-1,6u>)
INSTANCE(DenseAd::Evaluation<double,-1,7u>)
INSTANCE(DenseAd::Evaluation<double,-1,8u>)
INSTANCE(DenseAd::Evaluation<double,-1,9u>)
INSTANCE(DenseAd::Evaluation<double,-1,10u>)
INSTANCE(DenseAd::Evaluation<double,-1,11u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace Opm

46
opm/simulators/wells/WellGroupHelpers.cpp
View File

@ -1762,25 +1762,35 @@ updateGuideRatesForWells(const Schedule& schedule,
}
}
template class WellGroupHelpers<double>;
template<class Scalar>
using AvgP = RegionAverageCalculator::
AverageRegionalPressure<BlackOilFluidSystem<Scalar>,std::vector<int>>;
using AvgP = RegionAverageCalculator::AverageRegionalPressure<BlackOilFluidSystem<double>,std::vector<int>>;
using AvgPMap = std::map<std::string, std::unique_ptr<AvgP>>;
template<class Scalar>
using AvgPMap = std::map<std::string, std::unique_ptr<AvgP<Scalar>>>;
template void WellGroupHelpers<double>::
updateGpMaintTargetForGroups<AvgPMap>(const Group&,
const Schedule&,
const AvgPMap&,
int,
double,
const WellState<double>&,
GroupState<double>&);
template void WellGroupHelpers<double>::
setRegionAveragePressureCalculator<AvgP>(const Group&,
const Schedule&,
const int,
const FieldPropsManager&,
const PhaseUsage&,
AvgPMap&);
#define INSTANTIATE_TYPE(T) \
template class WellGroupHelpers<T>; \
template void WellGroupHelpers<T>:: \
updateGpMaintTargetForGroups<AvgPMap<T>>(const Group&, \
const Schedule&, \
const AvgPMap<T>&, \
int, \
double, \
const WellState<T>&, \
GroupState<T>&); \
template void WellGroupHelpers<T>:: \
setRegionAveragePressureCalculator<AvgP<T>>(const Group&, \
const Schedule&, \
const int, \
const FieldPropsManager&, \
const PhaseUsage&, \
AvgPMap<T>&);
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace Opm::WellGroupHelpers

58
opm/simulators/wells/WellHelpers.cpp
View File

@ -215,34 +215,42 @@ bool rateControlWithZeroInjTarget(const WellInjectionControls& controls,
}
}
template class ParallelStandardWellB<double>;
template<int Dim> using Vec = Dune::BlockVector<Dune::FieldVector<double,Dim>>;
using DynVec = Dune::BlockVector<Dune::DynamicVector<double>>;
#define INSTANCE(Dim) \
template void ParallelStandardWellB<double>::mv<Vec<Dim>,DynVec>(const Vec<Dim>&,DynVec&) const; \
template void ParallelStandardWellB<double>::mmv<Vec<Dim>,DynVec>(const Vec<Dim>&,DynVec&) const;
INSTANCE(1)
INSTANCE(2)
INSTANCE(3)
INSTANCE(4)
INSTANCE(5)
INSTANCE(6)
template<class Scalar, int Dim>
using Vec = Dune::BlockVector<Dune::FieldVector<Scalar,Dim>>;
template<class Scalar>
using DynVec = Dune::BlockVector<Dune::DynamicVector<Scalar>>;
template<class Scalar>
using DMatrix = Dune::DynamicMatrix<Scalar>;
using Comm = Parallel::Communication;
template void sumDistributedWellEntries<double,Comm>(Dune::DynamicMatrix<double>& mat,
Dune::DynamicVector<double>& vec,
const Comm& comm);
using DMatrix = Dune::DynamicMatrix<double>;
template DMatrix transposeDenseDynMatrix<DMatrix>(const DMatrix&);
#define INSTANTIATE(T,Dim) \
template void ParallelStandardWellB<T>:: \
mv(const Vec<T,Dim>&,DynVec<T>&) const; \
template void ParallelStandardWellB<T>:: \
mmv(const Vec<T,Dim>&,DynVec<T>&) const;
template double computeHydrostaticCorrection<double>(const double,
const double,
const double,
const double);
#define INSTANTIATE_TYPE(T) \
template class ParallelStandardWellB<T>; \
template void sumDistributedWellEntries(Dune::DynamicMatrix<T>& mat, \
Dune::DynamicVector<T>& vec, \
const Comm& comm); \
template DMatrix<T> transposeDenseDynMatrix(const DMatrix<T>&); \
template T computeHydrostaticCorrection(const T, \
const T, \
const T, \
const T); \
INSTANTIATE(T,1) \
INSTANTIATE(T,2) \
INSTANTIATE(T,3) \
INSTANTIATE(T,4) \
INSTANTIATE(T,5) \
INSTANTIATE(T,6)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace wellhelpers
} // namespace Opm

9
opm/simulators/wells/WellInterfaceFluidSystem.cpp
View File

@ -342,6 +342,13 @@ zeroGroupRateTarget(const SummaryState& summary_state,
}
}
template class WellInterfaceFluidSystem<BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>>;
template<class Scalar>
using FS = BlackOilFluidSystem<Scalar,BlackOilDefaultIndexTraits>;
template class WellInterfaceFluidSystem<FS<double>>;
#if FLOW_INSTANTIATE_FLOAT
template class WellInterfaceFluidSystem<FS<float>>;
#endif
} // namespace Opm

4
opm/simulators/wells/WellInterfaceGeneric.cpp
View File

@ -869,4 +869,8 @@ prepareForPotentialCalculations(const SummaryState& summary_state,
template class WellInterfaceGeneric<double>;
#if FLOW_INSTANTIATE_FLOAT
template class WellInterfaceGeneric<float>;
#endif
} // namespace Opm

70
opm/simulators/wells/WellInterfaceIndices.cpp
View File

@ -110,41 +110,45 @@ scalingFactor(const int phaseIdx) const
return 1.0;
}
#define INSTANCE( ...) \
template class WellInterfaceIndices<BlackOilFluidSystem<double,BlackOilDefaultIndexTraits>, \
__VA_ARGS__>;
template<class Scalar>
using FS = BlackOilFluidSystem<Scalar,BlackOilDefaultIndexTraits>;
// One phase
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>)
#define INSTANTIATE(T,...) \
template class WellInterfaceIndices<FS<T>, __VA_ARGS__>;
// Two phase
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,true,0u,2u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>)
INSTANCE(BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>)
#define INSTANTIATE_TYPE(T) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilOnePhaseIndices<0u,0u,0u,0u,false,false,0u,1u,5u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,2u,0u,false,false,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,1u,0u,false,true,0u,2u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,1u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,0u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<0u,0u,0u,1u,false,true,0u,0u,0u>) \
INSTANTIATE(T,BlackOilTwoPhaseIndices<1u,0u,0u,0u,false,false,0u,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,true,2u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,false,1u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,0u,false,false,1u,0u>) \
INSTANTIATE(T,BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>) \
INSTANTIATE(T,BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
// Blackoil
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,true,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,true,2u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,1u,0u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,1u,0u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,false,0u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,false,1u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,0u,false,false,1u,0u>)
INSTANCE(BlackOilIndices<0u,0u,0u,1u,false,true,0u,0u>)
INSTANCE(BlackOilIndices<1u,0u,0u,0u,true,false,0u,0u>)
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif
} // namespace Opm

21
opm/simulators/wells/WellProdIndexCalculator.cpp
View File

@ -152,10 +152,17 @@ Scalar Opm::wellProdIndStandard(const WellProdIndexCalculator<Scalar>& wellPICal
return std::accumulate(connPI.begin(), connPI.end(), 0.0);
}
template class Opm::WellProdIndexCalculator<double>;
template std::vector<double>
Opm::connectionProdIndStandard(const WellProdIndexCalculator<double>&,
const std::vector<double>&);
template double
Opm::wellProdIndStandard(const WellProdIndexCalculator<double>&,
const std::vector<double>&);
#define INSTANTIATE_TYPE(T) \
template class Opm::WellProdIndexCalculator<T>; \
template std::vector<T> \
Opm::connectionProdIndStandard(const WellProdIndexCalculator<T>&, \
const std::vector<T>&); \
template T \
Opm::wellProdIndStandard(const WellProdIndexCalculator<T>&, \
const std::vector<T>&);
INSTANTIATE_TYPE(double)
#if FLOW_INSTANTIATE_FLOAT
INSTANTIATE_TYPE(float)
#endif

4
opm/simulators/wells/WellState.cpp
View File

@ -1063,4 +1063,8 @@ WellState<Scalar>::parallelWellInfo(std::size_t well_index) const
template class WellState<double>;
#if FLOW_INSTANTIATE_FLOAT
template class WellState<float>;
#endif
} // namespace Opm

4
opm/simulators/wells/WellTest.cpp
View File

@ -481,4 +481,8 @@ updateWellTestStatePhysical(const double simulation_time,
template class WellTest<double>;
#if FLOW_INSTANTIATE_FLOAT
template class WellTest<float>;
#endif
} // namespace Opm