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

changed: remove NEW_PROP_TAG macro usage

Browse Source
This commit is contained in:
Arne Morten Kvarving
2020-08-27 11:38:38 +02:00
parent 941e4916f8
commit 93a3ebf8f7
14 changed files with 468 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
ebos/eclbasevanguard.hh
View File

@@ -72,15 +72,42 @@ struct EclBaseVanguard {};
} }
// declare the properties required by the for the ecl simulator vanguard // declare the properties required by the for the ecl simulator vanguard
NEW_PROP_TAG(EquilGrid); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(EclDeckFileName); struct EquilGrid {
NEW_PROP_TAG(EnableOpmRstFile); using type = UndefinedProperty;
NEW_PROP_TAG(EclStrictParsing); };
NEW_PROP_TAG(SchedRestart); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(EclOutputInterval); struct EclDeckFileName {
NEW_PROP_TAG(IgnoreKeywords); using type = UndefinedProperty;
NEW_PROP_TAG(EdgeWeightsMethod); };
NEW_PROP_TAG(OwnerCellsFirst); template<class TypeTag, class MyTypeTag>
struct EnableOpmRstFile {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EclStrictParsing {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct SchedRestart {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EclOutputInterval {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct IgnoreKeywords {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EdgeWeightsMethod {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct OwnerCellsFirst {
using type = UndefinedProperty;
};
template<class TypeTag> template<class TypeTag>
struct IgnoreKeywords<TypeTag, TTag::EclBaseVanguard> { struct IgnoreKeywords<TypeTag, TTag::EclBaseVanguard> {

25
ebos/eclnewtonmethod.hh
View File

@@ -37,11 +37,26 @@
namespace Opm::Properties { namespace Opm::Properties {
NEW_PROP_TAG(EclNewtonSumTolerance); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(EclNewtonStrictIterations); struct EclNewtonSumTolerance {
NEW_PROP_TAG(EclNewtonRelaxedVolumeFraction); using type = UndefinedProperty;
NEW_PROP_TAG(EclNewtonSumToleranceExponent); };
NEW_PROP_TAG(EclNewtonRelaxedTolerance); template<class TypeTag, class MyTypeTag>
struct EclNewtonStrictIterations {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EclNewtonRelaxedVolumeFraction {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EclNewtonSumToleranceExponent {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EclNewtonRelaxedTolerance {
using type = UndefinedProperty;
};
} // namespace Opm::Properties } // namespace Opm::Properties

5
ebos/ecloutputblackoilmodule.hh
View File

@@ -51,7 +51,10 @@ namespace TTag {
struct EclOutputBlackOil {}; struct EclOutputBlackOil {};
} }
NEW_PROP_TAG(ForceDisableFluidInPlaceOutput); template<class TypeTag, class MyTypeTag>
struct ForceDisableFluidInPlaceOutput {
using type = UndefinedProperty;
};
template<class TypeTag> template<class TypeTag>
struct ForceDisableFluidInPlaceOutput<TypeTag, TTag::EclOutputBlackOil> { struct ForceDisableFluidInPlaceOutput<TypeTag, TTag::EclOutputBlackOil> {

65
ebos/eclproblem.hh
View File

@@ -135,43 +135,82 @@ struct EclBaseProblem {
} }
// The class which deals with ECL wells // The class which deals with ECL wells
NEW_PROP_TAG(EclWellModel); template<class TypeTag, class MyTypeTag>
struct EclWellModel {
using type = UndefinedProperty;
};
// Write all solutions for visualization, not just the ones for the // Write all solutions for visualization, not just the ones for the
// report steps... // report steps...
NEW_PROP_TAG(EnableWriteAllSolutions); template<class TypeTag, class MyTypeTag>
struct EnableWriteAllSolutions {
using type = UndefinedProperty;
};
// The number of time steps skipped between writing two consequtive restart files // The number of time steps skipped between writing two consequtive restart files
NEW_PROP_TAG(RestartWritingInterval); template<class TypeTag, class MyTypeTag>
struct RestartWritingInterval {
using type = UndefinedProperty;
};
// Enable partial compensation of systematic mass losses via the source term of the next time // Enable partial compensation of systematic mass losses via the source term of the next time
// step // step
NEW_PROP_TAG(EclEnableDriftCompensation); template<class TypeTag, class MyTypeTag>
struct EclEnableDriftCompensation {
using type = UndefinedProperty;
};
// Enable the additional checks even if compiled in debug mode (i.e., with the NDEBUG // Enable the additional checks even if compiled in debug mode (i.e., with the NDEBUG
// macro undefined). Next to a slightly better performance, this also eliminates some // macro undefined). Next to a slightly better performance, this also eliminates some
// print statements in debug mode. // print statements in debug mode.
NEW_PROP_TAG(EnableDebuggingChecks); template<class TypeTag, class MyTypeTag>
struct EnableDebuggingChecks {
using type = UndefinedProperty;
};
// if thermal flux boundaries are enabled an effort is made to preserve the initial // if thermal flux boundaries are enabled an effort is made to preserve the initial
// thermal gradient specified via the TEMPVD keyword // thermal gradient specified via the TEMPVD keyword
NEW_PROP_TAG(EnableThermalFluxBoundaries); template<class TypeTag, class MyTypeTag>
struct EnableThermalFluxBoundaries {
using type = UndefinedProperty;
};
// Specify whether API tracking should be enabled (replaces PVT regions). // Specify whether API tracking should be enabled (replaces PVT regions).
// TODO: This is not yet implemented // TODO: This is not yet implemented
NEW_PROP_TAG(EnableApiTracking); template<class TypeTag, class MyTypeTag>
struct EnableApiTracking {
using type = UndefinedProperty;
};
// The class which deals with ECL aquifers // The class which deals with ECL aquifers
NEW_PROP_TAG(EclAquiferModel); template<class TypeTag, class MyTypeTag>
struct EclAquiferModel {
using type = UndefinedProperty;
};
// In experimental mode, decides if the aquifer model should be enabled or not // In experimental mode, decides if the aquifer model should be enabled or not
NEW_PROP_TAG(EclEnableAquifers); template<class TypeTag, class MyTypeTag>
struct EclEnableAquifers {
using type = UndefinedProperty;
};
// time stepping parameters // time stepping parameters
NEW_PROP_TAG(EclMaxTimeStepSizeAfterWellEvent); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(EclRestartShrinkFactor); struct EclMaxTimeStepSizeAfterWellEvent {
NEW_PROP_TAG(EclEnableTuning); using type = UndefinedProperty;
NEW_PROP_TAG(OutputMode); };
template<class TypeTag, class MyTypeTag>
struct EclRestartShrinkFactor {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EclEnableTuning {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct OutputMode {
using type = UndefinedProperty;
};
// Set the problem property // Set the problem property
SET_TYPE_PROP(EclBaseProblem, Problem, Opm::EclProblem<TypeTag>); SET_TYPE_PROP(EclBaseProblem, Problem, Opm::EclProblem<TypeTag>);

5
ebos/ecltracermodel.hh
View File

@@ -44,7 +44,10 @@
namespace Opm::Properties { namespace Opm::Properties {
NEW_PROP_TAG(EnableTracerModel); template<class TypeTag, class MyTypeTag>
struct EnableTracerModel {
using type = UndefinedProperty;
};
} // namespace Opm::Properties } // namespace Opm::Properties

15
ebos/eclwriter.hh
View File

@@ -68,9 +68,18 @@
namespace Opm::Properties { namespace Opm::Properties {
NEW_PROP_TAG(EnableEclOutput); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(EnableAsyncEclOutput); struct EnableEclOutput {
NEW_PROP_TAG(EclOutputDoublePrecision); using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EnableAsyncEclOutput {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EclOutputDoublePrecision {
using type = UndefinedProperty;
};
} // namespace Opm::Properties } // namespace Opm::Properties

5
ebos/vtkecltracermodule.hh
View File

@@ -48,7 +48,10 @@ struct VtkEclTracer {};
} }
// create the property tags needed for the tracer model // create the property tags needed for the tracer model
NEW_PROP_TAG(VtkWriteEclTracerConcentration); template<class TypeTag, class MyTypeTag>
struct VtkWriteEclTracerConcentration {
using type = UndefinedProperty;
};
// set default values for what quantities to output // set default values for what quantities to output
template<class TypeTag> template<class TypeTag>

140
opm/simulators/flow/BlackoilModelParametersEbos.hpp
View File

@@ -31,36 +31,120 @@ namespace TTag {
struct FlowModelParameters {}; struct FlowModelParameters {};
} }
NEW_PROP_TAG(DbhpMaxRel); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(DwellFractionMax); struct DbhpMaxRel {
NEW_PROP_TAG(MaxResidualAllowed); using type = UndefinedProperty;
NEW_PROP_TAG(RelaxedMaxPvFraction); };
NEW_PROP_TAG(ToleranceMb); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(ToleranceCnv); struct DwellFractionMax {
NEW_PROP_TAG(ToleranceCnvRelaxed); using type = UndefinedProperty;
NEW_PROP_TAG(ToleranceWells); };
NEW_PROP_TAG(ToleranceWellControl); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(MaxWelleqIter); struct MaxResidualAllowed {
NEW_PROP_TAG(UseMultisegmentWell); using type = UndefinedProperty;
NEW_PROP_TAG(MaxSinglePrecisionDays); };
NEW_PROP_TAG(MaxStrictIter); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(SolveWelleqInitially); struct RelaxedMaxPvFraction {
NEW_PROP_TAG(UpdateEquationsScaling); using type = UndefinedProperty;
NEW_PROP_TAG(UseUpdateStabilization); };
NEW_PROP_TAG(MatrixAddWellContributions); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(EnableWellOperabilityCheck); struct ToleranceMb {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct ToleranceCnv {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct ToleranceCnvRelaxed {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct ToleranceWells {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct ToleranceWellControl {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct MaxWelleqIter {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct UseMultisegmentWell {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct MaxSinglePrecisionDays {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct MaxStrictIter {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct SolveWelleqInitially {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct UpdateEquationsScaling {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct UseUpdateStabilization {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct MatrixAddWellContributions {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EnableWellOperabilityCheck {
using type = UndefinedProperty;
};
// parameters for multisegment wells // parameters for multisegment wells
NEW_PROP_TAG(TolerancePressureMsWells); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(MaxPressureChangeMsWells); struct TolerancePressureMsWells {
NEW_PROP_TAG(UseInnerIterationsMsWells); using type = UndefinedProperty;
NEW_PROP_TAG(MaxInnerIterMsWells); };
NEW_PROP_TAG(StrictInnerIterMsWells); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(RelaxedFlowTolInnerIterMsw); struct MaxPressureChangeMsWells {
NEW_PROP_TAG(RelaxedPressureTolInnerIterMsw); using type = UndefinedProperty;
NEW_PROP_TAG(RegularizationFactorMsw); };
NEW_PROP_TAG(UseInnerIterationsWells); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(MaxInnerIterWells); struct UseInnerIterationsMsWells {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct MaxInnerIterMsWells {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct StrictInnerIterMsWells {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct RelaxedFlowTolInnerIterMsw {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct RelaxedPressureTolInnerIterMsw {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct RegularizationFactorMsw {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct UseInnerIterationsWells {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct MaxInnerIterWells {
using type = UndefinedProperty;
};
template<class TypeTag> template<class TypeTag>
struct DbhpMaxRel<TypeTag, TTag::FlowModelParameters> { struct DbhpMaxRel<TypeTag, TTag::FlowModelParameters> {

15
opm/simulators/flow/FlowMainEbos.hpp
View File

@@ -50,9 +50,18 @@
namespace Opm::Properties { namespace Opm::Properties {
NEW_PROP_TAG(EnableDryRun); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(OutputInterval); struct EnableDryRun {
NEW_PROP_TAG(EnableLoggingFalloutWarning); using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct OutputInterval {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EnableLoggingFalloutWarning {
using type = UndefinedProperty;
};
// TODO: enumeration parameters. we use strings for now. // TODO: enumeration parameters. we use strings for now.
template<class TypeTag> template<class TypeTag>

20
opm/simulators/flow/NonlinearSolverEbos.hpp
View File

@@ -40,10 +40,22 @@ namespace TTag {
struct FlowNonLinearSolver {}; struct FlowNonLinearSolver {};
} }
NEW_PROP_TAG(NewtonMaxRelax); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(FlowNewtonMaxIterations); struct NewtonMaxRelax {
NEW_PROP_TAG(FlowNewtonMinIterations); using type = UndefinedProperty;
NEW_PROP_TAG(NewtonRelaxationType); };
template<class TypeTag, class MyTypeTag>
struct FlowNewtonMaxIterations {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct FlowNewtonMinIterations{
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct NewtonRelaxationType{
using type = UndefinedProperty;
};
template<class TypeTag> template<class TypeTag>
struct NewtonMaxRelax<TypeTag, TTag::FlowNonLinearSolver> { struct NewtonMaxRelax<TypeTag, TTag::FlowNonLinearSolver> {

10
opm/simulators/flow/SimulatorFullyImplicitBlackoilEbos.hpp
View File

@@ -36,8 +36,14 @@
namespace Opm::Properties { namespace Opm::Properties {
NEW_PROP_TAG(EnableAdaptiveTimeStepping); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(EnableTuning); struct EnableAdaptiveTimeStepping {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct EnableTuning {
using type = UndefinedProperty;
};
template<class TypeTag> template<class TypeTag>
struct EnableTerminalOutput<TypeTag, TTag::EclFlowProblem> { struct EnableTerminalOutput<TypeTag, TTag::EclFlowProblem> {

135
opm/simulators/linalg/FlowLinearSolverParameters.hpp
View File

@@ -45,33 +45,114 @@ namespace TTag {
struct FlowIstlSolverParams {}; struct FlowIstlSolverParams {};
} }
NEW_PROP_TAG(LinearSolverReduction); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(IluRelaxation); struct LinearSolverReduction {
NEW_PROP_TAG(LinearSolverMaxIter); using type = UndefinedProperty;
NEW_PROP_TAG(LinearSolverRestart); };
NEW_PROP_TAG(FlowLinearSolverVerbosity); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(IluFillinLevel); struct IluRelaxation {
NEW_PROP_TAG(MiluVariant); using type = UndefinedProperty;
NEW_PROP_TAG(IluRedblack); };
NEW_PROP_TAG(IluReorderSpheres); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(UseGmres); struct LinearSolverMaxIter {
NEW_PROP_TAG(LinearSolverRequireFullSparsityPattern); using type = UndefinedProperty;
NEW_PROP_TAG(LinearSolverIgnoreConvergenceFailure); };
NEW_PROP_TAG(UseAmg); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(UseCpr); struct LinearSolverRestart {
NEW_PROP_TAG(PreconditionerAddWellContributions); using type = UndefinedProperty;
NEW_PROP_TAG(SystemStrategy); };
NEW_PROP_TAG(ScaleLinearSystem); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(CprSolverVerbose); struct FlowLinearSolverVerbosity {
NEW_PROP_TAG(CprUseDrs); using type = UndefinedProperty;
NEW_PROP_TAG(CprMaxEllIter); };
NEW_PROP_TAG(CprEllSolvetype); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(CprReuseSetup); struct IluFillinLevel {
NEW_PROP_TAG(LinearSolverConfiguration); using type = UndefinedProperty;
NEW_PROP_TAG(LinearSolverConfigurationJsonFile); };
NEW_PROP_TAG(GpuMode); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(BdaDeviceId); struct MiluVariant {
NEW_PROP_TAG(OpenclPlatformId); using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct IluRedblack {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct IluReorderSpheres {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct UseGmres {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct LinearSolverRequireFullSparsityPattern {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct LinearSolverIgnoreConvergenceFailure{
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct UseAmg {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct UseCpr {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct PreconditionerAddWellContributions {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct SystemStrategy {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct ScaleLinearSystem {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct CprSolverVerbose {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct CprUseDrs {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct CprMaxEllIter {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct CprEllSolvetype {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct CprReuseSetup {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct LinearSolverConfiguration {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct LinearSolverConfigurationJsonFile {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct GpuMode {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct BdaDeviceId {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct OpenclPlatformId {
using type = UndefinedProperty;
};
template<class TypeTag> template<class TypeTag>
struct LinearSolverReduction<TypeTag, TTag::FlowIstlSolverParams> { struct LinearSolverReduction<TypeTag, TTag::FlowIstlSolverParams> {

95
opm/simulators/timestepping/AdaptiveTimeSteppingEbos.hpp
View File

@@ -23,25 +23,82 @@ namespace TTag {
struct FlowTimeSteppingParameters {}; struct FlowTimeSteppingParameters {};
} }
NEW_PROP_TAG(SolverRestartFactor); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(SolverGrowthFactor); struct SolverRestartFactor {
NEW_PROP_TAG(SolverMaxGrowth); using type = UndefinedProperty;
NEW_PROP_TAG(SolverMaxTimeStepInDays); };
NEW_PROP_TAG(SolverMinTimeStep); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(SolverMaxRestarts); struct SolverGrowthFactor {
NEW_PROP_TAG(SolverVerbosity); using type = UndefinedProperty;
NEW_PROP_TAG(TimeStepVerbosity); };
NEW_PROP_TAG(InitialTimeStepInDays); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(FullTimeStepInitially); struct SolverMaxGrowth {
NEW_PROP_TAG(TimeStepAfterEventInDays); using type = UndefinedProperty;
NEW_PROP_TAG(TimeStepControl); };
NEW_PROP_TAG(TimeStepControlTolerance); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(TimeStepControlTargetIterations); struct SolverMaxTimeStepInDays {
NEW_PROP_TAG(TimeStepControlTargetNewtonIterations); using type = UndefinedProperty;
NEW_PROP_TAG(TimeStepControlDecayRate); };
NEW_PROP_TAG(TimeStepControlGrowthRate); template<class TypeTag, class MyTypeTag>
NEW_PROP_TAG(TimeStepControlFileName); struct SolverMinTimeStep {
NEW_PROP_TAG(MinTimeStepBeforeShuttingProblematicWellsInDays); using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct SolverMaxRestarts {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct SolverVerbosity {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct TimeStepVerbosity {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct InitialTimeStepInDays {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct FullTimeStepInitially {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct TimeStepAfterEventInDays {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct TimeStepControl {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct TimeStepControlTolerance {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct TimeStepControlTargetIterations {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct TimeStepControlTargetNewtonIterations {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct TimeStepControlDecayRate {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct TimeStepControlGrowthRate {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct TimeStepControlFileName {
using type = UndefinedProperty;
};
template<class TypeTag, class MyTypeTag>
struct MinTimeStepBeforeShuttingProblematicWellsInDays {
using type = UndefinedProperty;
};
template<class TypeTag> template<class TypeTag>
struct SolverRestartFactor<TypeTag, TTag::FlowTimeSteppingParameters> { struct SolverRestartFactor<TypeTag, TTag::FlowTimeSteppingParameters> {

5
opm/simulators/wells/BlackoilWellModel.hpp
View File

@@ -63,7 +63,10 @@
namespace Opm::Properties { namespace Opm::Properties {
NEW_PROP_TAG(EnableTerminalOutput); template<class TypeTag, class MyTypeTag>
struct EnableTerminalOutput {
using type = UndefinedProperty;
};
} // namespace Opm::Properties } // namespace Opm::Properties