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

adjust to removal of EWOMS_REGISTER_PARAM

Browse Source
This commit is contained in:
Arne Morten Kvarving 2024-04-04 09:51:37 +02:00
parent c8e26b8e35
commit 6fba1a95c9
16 changed files with 435 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

173
opm/simulators/flow/BlackoilModelParameters.hpp
View File

@ -681,61 +681,124 @@ namespace Opm
static void registerParameters() static void registerParameters()
{ {
EWOMS_REGISTER_PARAM(TypeTag, Scalar, DbhpMaxRel, "Maximum relative change of the bottom-hole pressure in a single iteration"); Parameters::registerParam<TypeTag, Properties::DbhpMaxRel>
EWOMS_REGISTER_PARAM(TypeTag, Scalar, DwellFractionMax, "Maximum absolute change of a well's volume fraction in a single iteration"); ("Maximum relative change of the bottom-hole pressure in a single iteration");
EWOMS_REGISTER_PARAM(TypeTag, Scalar, MaxResidualAllowed, "Absolute maximum tolerated for residuals without cutting the time step size"); Parameters::registerParam<TypeTag, Properties::DwellFractionMax>
EWOMS_REGISTER_PARAM(TypeTag, Scalar, RelaxedMaxPvFraction, "The fraction of the pore volume of the reservoir " ("Maximum absolute change of a well's volume fraction in a single iteration");
"where the volumetric error (CNV) may be voilated during strict Newton iterations."); Parameters::registerParam<TypeTag, Properties::MaxResidualAllowed>
EWOMS_REGISTER_PARAM(TypeTag, Scalar, ToleranceMb, "Tolerated mass balance error relative to total mass present"); ("Absolute maximum tolerated for residuals without cutting the time step size");
EWOMS_REGISTER_PARAM(TypeTag, Scalar, ToleranceMbRelaxed, "Relaxed tolerated mass balance error that applies for iterations after the iterations with the strict tolerance"); Parameters::registerParam<TypeTag, Properties::RelaxedMaxPvFraction>
EWOMS_REGISTER_PARAM(TypeTag, Scalar, ToleranceCnv, "Local convergence tolerance (Maximum of local saturation errors)"); ("The fraction of the pore volume of the reservoir "
EWOMS_REGISTER_PARAM(TypeTag, Scalar, ToleranceCnvRelaxed, "Relaxed local convergence tolerance that applies for iterations after the iterations with the strict tolerance"); "where the volumetric error (CNV) may be voilated "
EWOMS_REGISTER_PARAM(TypeTag, Scalar, ToleranceWells, "Well convergence tolerance"); "during strict Newton iterations.");
EWOMS_REGISTER_PARAM(TypeTag, Scalar, ToleranceWellControl, "Tolerance for the well control equations"); Parameters::registerParam<TypeTag, Properties::ToleranceMb>
EWOMS_REGISTER_PARAM(TypeTag, int, MaxWelleqIter, "Maximum number of iterations to determine solution the well equations"); ("Tolerated mass balance error relative to total mass present");
EWOMS_REGISTER_PARAM(TypeTag, bool, UseMultisegmentWell, "Use the well model for multi-segment wells instead of the one for single-segment wells"); Parameters::registerParam<TypeTag, Properties::ToleranceMbRelaxed>
EWOMS_REGISTER_PARAM(TypeTag, Scalar, TolerancePressureMsWells, "Tolerance for the pressure equations for multi-segment wells"); ("Relaxed tolerated mass balance error that applies for iterations "
EWOMS_REGISTER_PARAM(TypeTag, Scalar, RelaxedWellFlowTol, "Relaxed tolerance for the well flow residual"); "after the iterations with the strict tolerance");
EWOMS_REGISTER_PARAM(TypeTag, Scalar, RelaxedPressureTolMsw, "Relaxed tolerance for the MSW pressure solution"); Parameters::registerParam<TypeTag, Properties::ToleranceCnv>
EWOMS_REGISTER_PARAM(TypeTag, Scalar, MaxPressureChangeMsWells, "Maximum relative pressure change for a single iteration of the multi-segment well model"); ("Local convergence tolerance (Maximum of local saturation errors)");
EWOMS_REGISTER_PARAM(TypeTag, int, MaxInnerIterMsWells, "Maximum number of inner iterations for multi-segment wells"); Parameters::registerParam<TypeTag, Properties::ToleranceCnvRelaxed>
EWOMS_REGISTER_PARAM(TypeTag, int, StrictInnerIterWells, "Number of inner well iterations with strict tolerance"); ("Relaxed local convergence tolerance that applies for iterations "
EWOMS_REGISTER_PARAM(TypeTag, int, StrictOuterIterWells, "Number of newton iterations for which wells are checked with strict tolerance"); "after the iterations with the strict tolerance");
EWOMS_REGISTER_PARAM(TypeTag, int, MaxNewtonIterationsWithInnerWellIterations, "Maximum newton iterations with inner well iterations"); Parameters::registerParam<TypeTag, Properties::ToleranceWells>
EWOMS_REGISTER_PARAM(TypeTag, bool, ShutUnsolvableWells, "Shut unsolvable wells"); ("Well convergence tolerance");
EWOMS_REGISTER_PARAM(TypeTag, int, MaxInnerIterWells, "Maximum number of inner iterations for standard wells"); Parameters::registerParam<TypeTag, Properties::ToleranceWellControl>
EWOMS_REGISTER_PARAM(TypeTag, bool, AlternativeWellRateInit, "Use alternative well rate initialization procedure"); ("Tolerance for the well control equations");
EWOMS_REGISTER_PARAM(TypeTag, Scalar, RegularizationFactorWells, "Regularization factor for wells"); Parameters::registerParam<TypeTag, Properties::MaxWelleqIter>
EWOMS_REGISTER_PARAM(TypeTag, Scalar, MaxSinglePrecisionDays, "Maximum time step size where single precision floating point arithmetic can be used solving for the linear systems of equations"); ("Maximum number of iterations to determine solution the well equations");
EWOMS_REGISTER_PARAM(TypeTag, int, MinStrictCnvIter, "Minimum number of Newton iterations before relaxed tolerances can be used for the CNV convergence criterion"); Parameters::registerParam<TypeTag, Properties::UseMultisegmentWell>
EWOMS_REGISTER_PARAM(TypeTag, int, MinStrictMbIter, "Minimum number of Newton iterations before relaxed tolerances can be used for the MB convergence criterion. " ("Use the well model for multi-segment wells instead of the "
"Default -1 means that the relaxed tolerance is used when maximum number of Newton iterations are reached."); "one for single-segment wells");
EWOMS_REGISTER_PARAM(TypeTag, bool, SolveWelleqInitially, "Fully solve the well equations before each iteration of the reservoir model"); Parameters::registerParam<TypeTag, Properties::TolerancePressureMsWells>
EWOMS_REGISTER_PARAM(TypeTag, bool, UpdateEquationsScaling, "Update scaling factors for mass balance equations during the run"); ("Tolerance for the pressure equations for multi-segment wells");
EWOMS_REGISTER_PARAM(TypeTag, bool, UseUpdateStabilization, "Try to detect and correct oscillations or stagnation during the Newton method"); Parameters::registerParam<TypeTag, Properties::RelaxedWellFlowTol>
EWOMS_REGISTER_PARAM(TypeTag, bool, MatrixAddWellContributions, "Explicitly specify the influences of wells between cells in the Jacobian and preconditioner matrices"); ("Relaxed tolerance for the well flow residual");
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableWellOperabilityCheck, "Enable the well operability checking"); Parameters::registerParam<TypeTag, Properties::RelaxedPressureTolMsw>
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableWellOperabilityCheckIter, "Enable the well operability checking during iterations"); ("Relaxed tolerance for the MSW pressure solution");
EWOMS_REGISTER_PARAM(TypeTag, int, MaximumNumberOfWellSwitches, "Maximum number of times a well can switch to the same control"); Parameters::registerParam<TypeTag, Properties::MaxPressureChangeMsWells>
EWOMS_REGISTER_PARAM(TypeTag, bool, UseAverageDensityMsWells, "Approximate segment densitities by averaging over segment and its outlet"); ("Maximum relative pressure change for a single iteration "
EWOMS_REGISTER_PARAM(TypeTag, bool, LocalWellSolveControlSwitching, "Allow control switching during local well solutions"); "of the multi-segment well model");
EWOMS_REGISTER_PARAM(TypeTag, bool, UseImplicitIpr, "Compute implict IPR for stability checks and stable solution search"); Parameters::registerParam<TypeTag, Properties::MaxInnerIterMsWells>
EWOMS_REGISTER_PARAM(TypeTag, int, NetworkMaxStrictIterations, "Maximum iterations in network solver before relaxing tolerance"); ("Maximum number of inner iterations for multi-segment wells");
EWOMS_REGISTER_PARAM(TypeTag, int, NetworkMaxIterations, "Maximum number of iterations in the network solver before giving up"); Parameters::registerParam<TypeTag, Properties::StrictInnerIterWells>
EWOMS_REGISTER_PARAM(TypeTag, std::string, NonlinearSolver, "Choose nonlinear solver. Valid choices are newton or nldd."); ("Number of inner well iterations with strict tolerance");
EWOMS_REGISTER_PARAM(TypeTag, std::string, LocalSolveApproach, "Choose local solve approach. Valid choices are jacobi and gauss-seidel"); Parameters::registerParam<TypeTag, Properties::StrictOuterIterWells>
EWOMS_REGISTER_PARAM(TypeTag, int, MaxLocalSolveIterations, "Max iterations for local solves with NLDD nonlinear solver."); ("Number of newton iterations for which wells are checked with strict tolerance");
EWOMS_REGISTER_PARAM(TypeTag, Scalar, LocalToleranceScalingMb, "Set lower than 1.0 to use stricter convergence tolerance for local solves."); Parameters::registerParam<TypeTag, Properties::MaxNewtonIterationsWithInnerWellIterations>
EWOMS_REGISTER_PARAM(TypeTag, Scalar, LocalToleranceScalingCnv, "Set lower than 1.0 to use stricter convergence tolerance for local solves."); ("Maximum newton iterations with inner well iterations");
EWOMS_REGISTER_PARAM(TypeTag, int, NlddNumInitialNewtonIter, "Number of initial global Newton iterations when running the NLDD nonlinear solver."); Parameters::registerParam<TypeTag, Properties::ShutUnsolvableWells>
EWOMS_REGISTER_PARAM(TypeTag, int, NumLocalDomains, "Number of local domains for NLDD nonlinear solver."); ("Shut unsolvable wells");
EWOMS_REGISTER_PARAM(TypeTag, Scalar, LocalDomainsPartitioningImbalance, "Subdomain partitioning imbalance tolerance. 1.03 is 3 percent imbalance."); Parameters::registerParam<TypeTag, Properties::MaxInnerIterWells>
EWOMS_REGISTER_PARAM(TypeTag, std::string, LocalDomainsPartitioningMethod, "Subdomain partitioning method. " ("Maximum number of inner iterations for standard wells");
"Allowed values are 'zoltan', 'simple', and the name of a partition file ending with '.partition'."); Parameters::registerParam<TypeTag, Properties::AlternativeWellRateInit>
EWOMS_REGISTER_PARAM(TypeTag, std::string, LocalDomainsOrderingMeasure, "Subdomain ordering measure. " ("Use alternative well rate initialization procedure");
"Allowed values are 'maxpressure', 'averagepressure' and 'residual'."); Parameters::registerParam<TypeTag, Properties::RegularizationFactorWells>
("Regularization factor for wells");
EWOMS_REGISTER_PARAM(TypeTag, bool, DebugEmitCellPartition, "Whether or not to emit cell partitions as a debugging aid."); Parameters::registerParam<TypeTag, Properties::MaxSinglePrecisionDays>
("Maximum time step size where single precision floating point "
"arithmetic can be used solving for the linear systems of equations");
Parameters::registerParam<TypeTag, Properties::MinStrictCnvIter>
("Minimum number of Newton iterations before relaxed tolerances "
"can be used for the CNV convergence criterion");
Parameters::registerParam<TypeTag, Properties::MinStrictMbIter>
("Minimum number of Newton iterations before relaxed tolerances "
"can be used for the MB convergence criterion. "
"Default -1 means that the relaxed tolerance is used when maximum "
"number of Newton iterations are reached.");
Parameters::registerParam<TypeTag, Properties::SolveWelleqInitially>
("Fully solve the well equations before each iteration of the reservoir model");
Parameters::registerParam<TypeTag, Properties::UpdateEquationsScaling>
("Update scaling factors for mass balance equations during the run");
Parameters::registerParam<TypeTag, Properties::UseUpdateStabilization>
("Try to detect and correct oscillations or stagnation during the Newton method");
Parameters::registerParam<TypeTag, Properties::MatrixAddWellContributions>
("Explicitly specify the influences of wells between cells in "
"the Jacobian and preconditioner matrices");
Parameters::registerParam<TypeTag, Properties::EnableWellOperabilityCheck>
("Enable the well operability checking");
Parameters::registerParam<TypeTag, Properties::EnableWellOperabilityCheckIter>
("Enable the well operability checking during iterations");
Parameters::registerParam<TypeTag, Properties::MaximumNumberOfWellSwitches>
("Maximum number of times a well can switch to the same control");
Parameters::registerParam<TypeTag, Properties::UseAverageDensityMsWells>
("Approximate segment densitities by averaging over segment and its outlet");
Parameters::registerParam<TypeTag, Properties::LocalWellSolveControlSwitching>
("Allow control switching during local well solutions");
Parameters::registerParam<TypeTag, Properties::UseImplicitIpr>
("Compute implict IPR for stability checks and stable solution search");
Parameters::registerParam<TypeTag, Properties::NetworkMaxStrictIterations>
("Maximum iterations in network solver before relaxing tolerance");
Parameters::registerParam<TypeTag, Properties::NetworkMaxIterations>
("Maximum number of iterations in the network solver before giving up");
Parameters::registerParam<TypeTag, Properties::NonlinearSolver>
("Choose nonlinear solver. Valid choices are newton or nldd.");
Parameters::registerParam<TypeTag, Properties::LocalSolveApproach>
("Choose local solve approach. Valid choices are jacobi and gauss-seidel");
Parameters::registerParam<TypeTag, Properties::MaxLocalSolveIterations>
("Max iterations for local solves with NLDD nonlinear solver.");
Parameters::registerParam<TypeTag, Properties::LocalToleranceScalingMb>
("Set lower than 1.0 to use stricter convergence tolerance for local solves.");
Parameters::registerParam<TypeTag, Properties::LocalToleranceScalingCnv>
("Set lower than 1.0 to use stricter convergence tolerance for local solves.");
Parameters::registerParam<TypeTag, Properties::NlddNumInitialNewtonIter>
("Number of initial global Newton iterations when running the NLDD nonlinear solver.");
Parameters::registerParam<TypeTag, Properties::NumLocalDomains>
("Number of local domains for NLDD nonlinear solver.");
Parameters::registerParam<TypeTag, Properties::LocalDomainsPartitioningImbalance>
("Subdomain partitioning imbalance tolerance. 1.03 is 3 percent imbalance.");
Parameters::registerParam<TypeTag, Properties::LocalDomainsPartitioningMethod>
("Subdomain partitioning method. Allowed values are "
"'zoltan', "
"'simple', "
"and the name of a partition file ending with '.partition'.");
Parameters::registerParam<TypeTag, Properties::LocalDomainsOrderingMeasure>
("Subdomain ordering measure. Allowed values are "
"'maxpressure', "
"'averagepressure' "
"and 'residual'.");
Parameters::registerParam<TypeTag, Properties::DebugEmitCellPartition>
("Whether or not to emit cell partitions as a debugging aid.");
Parameters::hideParam<TypeTag>("DebugEmitCellPartition"); Parameters::hideParam<TypeTag>("DebugEmitCellPartition");
} }

88
opm/simulators/flow/DamarisWriter.hpp
View File

@ -103,43 +103,57 @@ class DamarisWriter : public EclGenericWriter<GetPropType<TypeTag, Properties::G
public: public:
static void registerParameters() static void registerParameters()
{ {
EWOMS_REGISTER_PARAM(TypeTag, bool, DamarisOutputHdfCollective, Parameters::registerParam<TypeTag, Properties::DamarisOutputHdfCollective>
"Write output via Damaris using parallel HDF5 to get single file and dataset per timestep instead of one per Damaris \n \ ("Write output via Damaris using parallel HDF5 to "
core with multiple datasets."); "get single file and dataset per timestep instead "
EWOMS_REGISTER_PARAM(TypeTag, bool, DamarisSaveToHdf, "of one per Damaris core with multiple datasets.");
"Set to false to prevent output to HDF5. Uses collective output by default or set --enable-damaris-collective=false to\n \ Parameters::registerParam<TypeTag, Properties::DamarisSaveToHdf>
use file per core (file per Damaris server)."); ("Set to false to prevent output to HDF5. "
EWOMS_REGISTER_PARAM(TypeTag, bool, DamarisSaveMeshToHdf, "Uses collective output by default or "
"Saves the mesh data to the HDF5 file (1st iteration only). Will set --damaris-output-hdf-collective to false \n \ "set --enable-damaris-collective=false to"
so will use file per core (file per Damaris server) output (global sizes and offset values \n \ "use file per core (file per Damaris server).");
of mesh variables are not being provided as yet)."); Parameters::registerParam<TypeTag, Properties::DamarisSaveMeshToHdf>
EWOMS_REGISTER_PARAM(TypeTag, std::string, DamarisPythonScript, ("Saves the mesh data to the HDF5 file (1st iteration only). "
"Set to the path and filename of a Python script to run on Damaris server resources with access to OPM flow data."); "Will set --damaris-output-hdf-collective to false "
EWOMS_REGISTER_PARAM(TypeTag, std::string, DamarisPythonParaviewScript, "so will use file per core (file per Damaris server) output "
"Set to the path and filename of a Paraview Python script to run on Paraview Catalyst (1 or 2) on Damaris server \n \ "(global sizes and offset values of mesh variables are not being provided as yet).");
resources with access to OPM flow data."); Parameters::registerParam<TypeTag, Properties::DamarisPythonScript>
EWOMS_REGISTER_PARAM(TypeTag, std::string, DamarisSimName, ("Set to the path and filename of a Python script to run on "
"The name of the simulation to be used by Damaris. If empty (the default) then Damaris uses \"opm-sim-<random-number>\". \n \ "Damaris server resources with access to OPM flow data.");
This name is used for the Damaris HDF5 file name prefix. Make unique if writing to the same output directory."); Parameters::registerParam<TypeTag, Properties::DamarisPythonParaviewScript>
EWOMS_REGISTER_PARAM(TypeTag, std::string, DamarisLogLevel, ("Set to the path and filename of a Paraview Python script "
"The log level for the Damaris logging system (boost log based). \n \ "to run on Paraview Catalyst (1 or 2) on Damaris server "
Levels are: [trace, debug, info, warning, error, fatal]. Currently debug and info are useful. "); "resources with access to OPM flow data.");
EWOMS_REGISTER_PARAM(TypeTag, std::string, DamarisDaskFile, Parameters::registerParam<TypeTag, Properties::DamarisSimName>
"The name of a Dask json configuration file (if using Dask for processing)."); ("The name of the simulation to be used by Damaris. "
"If empty (the default) then Damaris uses \"opm-sim-<random-number>\". "
EWOMS_REGISTER_PARAM(TypeTag, int, DamarisDedicatedCores, "This name is used for the Damaris HDF5 file name prefix. "
"Set the number of dedicated cores (MPI processes) that should be used for Damaris processing (per node). \n \ "Make unique if writing to the same output directory.");
Must divide evenly into the number of simulation ranks (client ranks)."); Parameters::registerParam<TypeTag, Properties::DamarisLogLevel>
EWOMS_REGISTER_PARAM(TypeTag, int, DamarisDedicatedNodes, ("The log level for the Damaris logging system (boost log based). "
"Set the number of dedicated nodes (full nodes) that should be used for Damaris processing (per simulation). \n \ "Levels are: [trace, debug, info, warning, error, fatal]. "
Must divide evenly into the number of simulation nodes."); "Currently debug and info are useful. ");
EWOMS_REGISTER_PARAM(TypeTag, long, DamarisSharedMemorySizeBytes, Parameters::registerParam<TypeTag, Properties::DamarisDaskFile>
"Set the size of the shared memory buffer used for IPC between the simulation and the Damaris resources. \n \ ("The name of a Dask json configuration file (if using Dask for processing).");
Needs to hold all the variables published, possibly over multiple simulation iterations."); Parameters::registerParam<TypeTag, Properties::DamarisDedicatedCores>
EWOMS_REGISTER_PARAM(TypeTag, std::string, DamarisSharedMemoryName, ("Set the number of dedicated cores (MPI processes) "
"The name of the shared memory area to be used by Damaris for the current. If empty (the default) then Damaris uses \"opm-damaris-<random-string>\". \n \ "that should be used for Damaris processing (per node). "
This name should be unique if multiple simulations are running on the same node/server as it is used for the Damaris shmem name and by the Python Dask \n \ "Must divide evenly into the number of simulation ranks (client ranks).");
library to locate sections of variables."); Parameters::registerParam<TypeTag, Properties::DamarisDedicatedNodes>
("Set the number of dedicated nodes (full nodes) "
"that should be used for Damaris processing (per simulation). "
"Must divide evenly into the number of simulation nodes.");
Parameters::registerParam<TypeTag, Properties::DamarisSharedMemorySizeBytes>
("Set the size of the shared memory buffer used for IPC "
"between the simulation and the Damaris resources. "
"Needs to hold all the variables published, possibly over "
"multiple simulation iterations.");
Parameters::registerParam<TypeTag, Properties::DamarisSharedMemoryName>
("The name of the shared memory area to be used by Damaris for the current. "
"If empty (the default) then Damaris uses \"opm-damaris-<random-string>\". "
"This name should be unique if multiple simulations are running on "
"the same node/server as it is used for the Damaris shmem name and by "
"the Python Dask library to locate sections of variables.");
} }
// The Simulator object should preferably have been const - the // The Simulator object should preferably have been const - the

11
opm/simulators/flow/EclWriter.hpp
View File

@ -124,12 +124,11 @@ public:
{ {
OutputBlackOilModule<TypeTag>::registerParameters(); OutputBlackOilModule<TypeTag>::registerParameters();
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableAsyncEclOutput, Parameters::registerParam<TypeTag, Properties::EnableAsyncEclOutput>
"Write the ECL-formated results in a non-blocking way (i.e., using a separate thread)."); ("Write the ECL-formated results in a non-blocking way "
"(i.e., using a separate thread).");
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableEsmry, Parameters::registerParam<TypeTag, Properties::EnableEsmry>
"Write ESMRY file for fast loading of summary data."); ("Write ESMRY file for fast loading of summary data.");
} }
// The Simulator object should preferably have been const - the // The Simulator object should preferably have been const - the

85
opm/simulators/flow/FlowBaseVanguard.hpp
View File

@ -238,56 +238,59 @@ public:
*/ */
static void registerParameters() static void registerParameters()
{ {
EWOMS_REGISTER_PARAM(TypeTag, std::string, EclDeckFileName, Parameters::registerParam<TypeTag, Properties::EclDeckFileName>
"The name of the file which contains the ECL deck to be simulated"); ("The name of the file which contains the ECL deck to be simulated");
EWOMS_REGISTER_PARAM(TypeTag, int, EclOutputInterval, Parameters::registerParam<TypeTag, Properties::EclOutputInterval>
"The number of report steps that ought to be skipped between two writes of ECL results"); ("The number of report steps that ought to be skipped between two writes of ECL results");
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableOpmRstFile, Parameters::registerParam<TypeTag, Properties::EnableOpmRstFile>
"Include OPM-specific keywords in the ECL restart file to enable restart of OPM simulators from these files"); ("Include OPM-specific keywords in the ECL restart file to "
EWOMS_REGISTER_PARAM(TypeTag, std::string, IgnoreKeywords, "enable restart of OPM simulators from these files");
"List of Eclipse keywords which should be ignored. As a ':' separated string."); Parameters::registerParam<TypeTag, Properties::IgnoreKeywords>
EWOMS_REGISTER_PARAM(TypeTag, std::string, ParsingStrictness, ("List of Eclipse keywords which should be ignored. As a ':' separated string.");
"Set strictness of parsing process. Available options are " Parameters::registerParam<TypeTag, Properties::ParsingStrictness>
"normal (stop for critical errors), " ("Set strictness of parsing process. Available options are "
"high (stop for all errors) and " "normal (stop for critical errors), "
"low (as normal, except do not stop due to unsupported keywords even if marked critical"); "high (stop for all errors) and "
EWOMS_REGISTER_PARAM(TypeTag, bool, SchedRestart, "low (as normal, except do not stop due to unsupported "
"When restarting: should we try to initialize wells and groups from historical SCHEDULE section."); "keywords even if marked critical");
EWOMS_REGISTER_PARAM(TypeTag, int, EdgeWeightsMethod, Parameters::registerParam<TypeTag, Properties::SchedRestart>
"Choose edge-weighing strategy: 0=uniform, 1=trans, 2=log(trans)."); ("When restarting: should we try to initialize wells and "
"groups from historical SCHEDULE section.");
Parameters::registerParam<TypeTag, Properties::EdgeWeightsMethod>
("Choose edge-weighing strategy: 0=uniform, 1=trans, 2=log(trans).");
#if HAVE_OPENCL || HAVE_ROCSPARSE || HAVE_CUDA #if HAVE_OPENCL || HAVE_ROCSPARSE || HAVE_CUDA
EWOMS_REGISTER_PARAM(TypeTag, int, NumJacobiBlocks, Parameters::registerParam<TypeTag, Properties::NumJacobiBlocks>
"Number of blocks to be created for the Block-Jacobi preconditioner."); ("Number of blocks to be created for the Block-Jacobi preconditioner.");
#endif #endif
EWOMS_REGISTER_PARAM(TypeTag, bool, OwnerCellsFirst, Parameters::registerParam<TypeTag, Properties::OwnerCellsFirst>
"Order cells owned by rank before ghost/overlap cells."); ("Order cells owned by rank before ghost/overlap cells.");
#if HAVE_MPI #if HAVE_MPI
EWOMS_REGISTER_PARAM(TypeTag, bool, SerialPartitioning, Parameters::registerParam<TypeTag, Properties::SerialPartitioning>
"Perform partitioning for parallel runs on a single process."); ("Perform partitioning for parallel runs on a single process.");
EWOMS_REGISTER_PARAM(TypeTag, double, ZoltanImbalanceTol, Parameters::registerParam<TypeTag, Properties::ZoltanImbalanceTol>
"Tolerable imbalance of the loadbalancing provided by Zoltan (default: 1.1)."); ("Tolerable imbalance of the loadbalancing provided by Zoltan (default: 1.1).");
EWOMS_REGISTER_PARAM(TypeTag, std::string, ZoltanParams, Parameters::registerParam<TypeTag, Properties::ZoltanParams>
"Configuration of Zoltan partitioner. " ("Configuration of Zoltan partitioner. "
"Valid options are: graph, hypergraph or scotch. " "Valid options are: graph, hypergraph or scotch. "
"Alternatively, you can request a configuration to be read " "Alternatively, you can request a configuration to be read "
"from a JSON file by giving the filename here, ending with '.json.' " "from a JSON file by giving the filename here, ending with '.json.' "
"See https://sandialabs.github.io/Zoltan/ug_html/ug.html " "See https://sandialabs.github.io/Zoltan/ug_html/ug.html "
"for available Zoltan options."); "for available Zoltan options.");
Parameters::hideParam<TypeTag>("ZoltanParams"); Parameters::hideParam<TypeTag>("ZoltanParams");
EWOMS_REGISTER_PARAM(TypeTag, std::string, ExternalPartition, Parameters::registerParam<TypeTag, Properties::ExternalPartition>
"Name of file from which to load an externally generated " ("Name of file from which to load an externally generated "
"partitioning of the model's active cells for MPI " "partitioning of the model's active cells for MPI "
"distribution purposes. If empty, the built-in partitioning " "distribution purposes. If empty, the built-in partitioning "
"method will be employed."); "method will be employed.");
Parameters::hideParam<TypeTag>("ExternalPartition"); Parameters::hideParam<TypeTag>("ExternalPartition");
#endif #endif
EWOMS_REGISTER_PARAM(TypeTag, bool, AllowDistributedWells, Parameters::registerParam<TypeTag, Properties::AllowDistributedWells>
"Allow the perforations of a well to be distributed to interior of multiple processes"); ("Allow the perforations of a well to be distributed to interior of multiple processes");
// register here for the use in the tests without BlackoilModelParameters // register here for the use in the tests without BlackoilModelParameters
EWOMS_REGISTER_PARAM(TypeTag, bool, UseMultisegmentWell, "Use the well model for multi-segment wells instead of the one for single-segment wells"); Parameters::registerParam<TypeTag, Properties::UseMultisegmentWell>
("Use the well model for multi-segment wells instead of the one for single-segment wells");
} }
/*! /*!

13
opm/simulators/flow/FlowMain.hpp
View File

@ -114,12 +114,13 @@ namespace Opm {
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
// register the flow specific parameters // register the flow specific parameters
EWOMS_REGISTER_PARAM(TypeTag, std::string, EnableDryRun, Parameters::registerParam<TypeTag, Properties::EnableDryRun>
"Specify if the simulation ought to be actually run, or just pretended to be"); ("Specify if the simulation ought to be actually run, or just pretended to be");
EWOMS_REGISTER_PARAM(TypeTag, int, OutputInterval, Parameters::registerParam<TypeTag, Properties::OutputInterval>
"Specify the number of report steps between two consecutive writes of restart data"); ("Specify the number of report steps between two consecutive writes of restart data");
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableLoggingFalloutWarning, Parameters::registerParam<TypeTag, Properties::EnableLoggingFalloutWarning>
"Developer option to see whether logging was on non-root processors. In that case it will be appended to the *.DBG or *.PRT files"); ("Developer option to see whether logging was on non-root processors. "
"In that case it will be appended to the *.DBG or *.PRT files");
Simulator::registerParameters(); Simulator::registerParameters();

42
opm/simulators/flow/FlowProblem.hpp
View File

@ -216,29 +216,31 @@ public:
VtkTracerModule<TypeTag>::registerParameters(); VtkTracerModule<TypeTag>::registerParameters();
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableWriteAllSolutions, Parameters::registerParam<TypeTag, Properties::EnableWriteAllSolutions>
"Write all solutions to disk instead of only the ones for the " ("Write all solutions to disk instead of only the ones for the "
"report steps"); "report steps");
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableEclOutput, Parameters::registerParam<TypeTag, Properties::EnableEclOutput>
"Write binary output which is compatible with the commercial " ("Write binary output which is compatible with the commercial "
"Eclipse simulator"); "Eclipse simulator");
#if HAVE_DAMARIS #if HAVE_DAMARIS
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableDamarisOutput, Parameters::registerParam<TypeTag, Properties::EnableDamarisOutput>
"Write a specific variable using Damaris in a separate core"); ("Write a specific variable using Damaris in a separate core");
#endif #endif
EWOMS_REGISTER_PARAM(TypeTag, bool, EclOutputDoublePrecision, Parameters::registerParam<TypeTag, Properties::EclOutputDoublePrecision>
"Tell the output writer to use double precision. Useful for 'perfect' restarts"); ("Tell the output writer to use double precision. Useful for 'perfect' restarts");
EWOMS_REGISTER_PARAM(TypeTag, unsigned, RestartWritingInterval, Parameters::registerParam<TypeTag, Properties::RestartWritingInterval>
"The frequencies of which time steps are serialized to disk"); ("The frequencies of which time steps are serialized to disk");
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableDriftCompensation, Parameters::registerParam<TypeTag, Properties::EnableDriftCompensation>
"Enable partial compensation of systematic mass losses via the source term of the next time step"); ("Enable partial compensation of systematic mass losses via "
EWOMS_REGISTER_PARAM(TypeTag, std::string, OutputMode, "the source term of the next time step");
"Specify which messages are going to be printed. Valid values are: none, log, all (default)"); Parameters::registerParam<TypeTag, Properties::OutputMode>
EWOMS_REGISTER_PARAM(TypeTag, int, NumPressurePointsEquil, ("Specify which messages are going to be printed. "
"Number of pressure points (in each direction) in tables used for equilibration"); "Valid values are: none, log, all (default)");
Parameters::registerParam<TypeTag, Properties::NumPressurePointsEquil>
("Number of pressure points (in each direction) in tables used for equilibration");
Parameters::hideParam<TypeTag>("NumPressurePointsEquil"); // Users will typically not need to modify this parameter.. Parameters::hideParam<TypeTag>("NumPressurePointsEquil"); // Users will typically not need to modify this parameter..
EWOMS_REGISTER_PARAM(TypeTag, bool, ExplicitRockCompaction, Parameters::registerParam<TypeTag, Properties::ExplicitRockCompaction>
"Use pressure from end of the last time step when evaluating rock compaction"); ("Use pressure from end of the last time step when evaluating rock compaction");
Parameters::hideParam<TypeTag>("ExplicitRockCompaction"); // Users will typically not need to modify this parameter.. Parameters::hideParam<TypeTag>("ExplicitRockCompaction"); // Users will typically not need to modify this parameter..
} }

12
opm/simulators/flow/NonlinearSolver.hpp
View File

@ -144,10 +144,14 @@ void stabilizeNonlinearUpdate(BVector& dx, BVector& dxOld,
static void registerParameters() static void registerParameters()
{ {
EWOMS_REGISTER_PARAM(TypeTag, Scalar, NewtonMaxRelax, "The maximum relaxation factor of a Newton iteration"); Parameters::registerParam<TypeTag, Properties::NewtonMaxRelax>
EWOMS_REGISTER_PARAM(TypeTag, int, NewtonMaxIterations, "The maximum number of Newton iterations per time step"); ("The maximum relaxation factor of a Newton iteration");
EWOMS_REGISTER_PARAM(TypeTag, int, NewtonMinIterations, "The minimum number of Newton iterations per time step"); Parameters::registerParam<TypeTag, Properties::NewtonMaxIterations>
EWOMS_REGISTER_PARAM(TypeTag, std::string, NewtonRelaxationType, "The type of relaxation used by Newton method"); ("The maximum number of Newton iterations per time step");
Parameters::registerParam<TypeTag, Properties::NewtonMinIterations>
("The minimum number of Newton iterations per time step");
Parameters::registerParam<TypeTag, Properties::NewtonRelaxationType>
("The type of relaxation used by Newton method");
} }
void reset() void reset()

16
opm/simulators/flow/OutputBlackoilModule.hpp
View File

@ -207,16 +207,12 @@ public:
*/ */
static void registerParameters() static void registerParameters()
{ {
EWOMS_REGISTER_PARAM( Parameters::registerParam<TypeTag, Properties::ForceDisableFluidInPlaceOutput>
TypeTag, ("Do not print fluid-in-place values after each report step "
bool, "even if requested by the deck.");
ForceDisableFluidInPlaceOutput, Parameters::registerParam<TypeTag, Properties::ForceDisableResvFluidInPlaceOutput>
"Do not print fluid-in-place values after each report step even if requested by the deck."); ("Do not print reservoir volumes values after each report step "
EWOMS_REGISTER_PARAM( "even if requested by the deck.");
TypeTag,
bool,
ForceDisableResvFluidInPlaceOutput,
"Do not print reservoir volumes values after each report step even if requested by the deck.");
} }
/*! /*!

60
opm/simulators/flow/SimulatorFullyImplicitBlackoil.hpp
View File

@ -219,37 +219,37 @@ public:
SolverParameters::registerParameters(); SolverParameters::registerParameters();
TimeStepper::registerParameters(); TimeStepper::registerParameters();
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableTerminalOutput, Parameters::registerParam<TypeTag, Properties::EnableTerminalOutput>
"Print high-level information about the simulation's progress to the terminal"); ("Print high-level information about the simulation's progress to the terminal");
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableAdaptiveTimeStepping, Parameters::registerParam<TypeTag, Properties::EnableAdaptiveTimeStepping>
"Use adaptive time stepping between report steps"); ("Use adaptive time stepping between report steps");
EWOMS_REGISTER_PARAM(TypeTag, std::string, OutputExtraConvergenceInfo, Parameters::registerParam<TypeTag, Properties::OutputExtraConvergenceInfo>
"Provide additional convergence output " ("Provide additional convergence output "
"files for diagnostic purposes. " "files for diagnostic purposes. "
"\"none\" gives no extra output and " "\"none\" gives no extra output and "
"overrides all other options, " "overrides all other options, "
"\"steps\" generates an INFOSTEP file, " "\"steps\" generates an INFOSTEP file, "
"\"iterations\" generates an INFOITER file. " "\"iterations\" generates an INFOITER file. "
"Combine options with commas, e.g., " "Combine options with commas, e.g., "
"\"steps,iterations\" for multiple outputs."); "\"steps,iterations\" for multiple outputs.");
EWOMS_REGISTER_PARAM(TypeTag, std::string, SaveStep, Parameters::registerParam<TypeTag, Properties::SaveStep>
"Save serialized state to .OPMRST file. " ("Save serialized state to .OPMRST file. "
"Either a specific report step, \"all\" to save " "Either a specific report step, \"all\" to save "
"all report steps or \":x\" to save every x'th step." "all report steps or \":x\" to save every x'th step."
"Use negative values of \"x\" to keep only the last " "Use negative values of \"x\" to keep only the last "
"written step, or \"last\" to save every step, keeping " "written step, or \"last\" to save every step, keeping "
"only the last."); "only the last.");
EWOMS_REGISTER_PARAM(TypeTag, int, LoadStep, Parameters::registerParam<TypeTag, Properties::LoadStep>
"Load serialized state from .OPMRST file. " ("Load serialized state from .OPMRST file. "
"Either a specific report step, or 0 to load last " "Either a specific report step, or 0 to load last "
"stored report step."); "stored report step.");
EWOMS_REGISTER_PARAM(TypeTag, std::string, SaveFile, Parameters::registerParam<TypeTag, Properties::SaveFile>
"FileName for .OPMRST file used for saving serialized state. " ("FileName for .OPMRST file used for saving serialized state. "
"If empty, CASENAME.OPMRST is used."); "If empty, CASENAME.OPMRST is used.");
Parameters::hideParam<TypeTag>("SaveFile"); Parameters::hideParam<TypeTag>("SaveFile");
EWOMS_REGISTER_PARAM(TypeTag, std::string, LoadFile, Parameters::registerParam<TypeTag, Properties::LoadFile>
"FileName for .OPMRST file used to load serialized state. " ("FileName for .OPMRST file used to load serialized state. "
"If empty, CASENAME.OPMRST is used."); "If empty, CASENAME.OPMRST is used.");
Parameters::hideParam<TypeTag>("LoadFile"); Parameters::hideParam<TypeTag>("LoadFile");
} }

5
opm/simulators/flow/VtkTracerModule.hpp
View File

@ -95,9 +95,8 @@ namespace Opm {
*/ */
static void registerParameters() static void registerParameters()
{ {
EWOMS_REGISTER_PARAM(TypeTag, bool, VtkWriteTracerConcentration, Parameters::registerParam<TypeTag, Properties::VtkWriteTracerConcentration>
"Include the tracer concentration " ("Include the tracer concentration in the VTK output files");
"in the VTK output files");
} }
/*! /*!

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

@ -294,27 +294,73 @@ namespace Opm
template <class TypeTag> template <class TypeTag>
static void registerParameters() static void registerParameters()
{ {
EWOMS_REGISTER_PARAM(TypeTag, double, LinearSolverReduction, "The minimum reduction of the residual which the linear solver must achieve"); Parameters::registerParam<TypeTag, Properties::LinearSolverReduction>
EWOMS_REGISTER_PARAM(TypeTag, double, RelaxedLinearSolverReduction, "The minimum reduction of the residual which the linear solver need to achieve for the solution to be accepted"); ("The minimum reduction of the residual which the linear solver must achieve");
EWOMS_REGISTER_PARAM(TypeTag, int, LinearSolverMaxIter, "The maximum number of iterations of the linear solver"); Parameters::registerParam<TypeTag, Properties::RelaxedLinearSolverReduction>
EWOMS_REGISTER_PARAM(TypeTag, int, LinearSolverRestart, "The number of iterations after which GMRES is restarted"); ("The minimum reduction of the residual which the linear solver need to "
EWOMS_REGISTER_PARAM(TypeTag, int, LinearSolverVerbosity, "The verbosity level of the linear solver (0: off, 2: all)"); "achieve for the solution to be accepted");
EWOMS_REGISTER_PARAM(TypeTag, double, IluRelaxation, "The relaxation factor of the linear solver's ILU preconditioner"); Parameters::registerParam<TypeTag, Properties::LinearSolverMaxIter>
EWOMS_REGISTER_PARAM(TypeTag, int, IluFillinLevel, "The fill-in level of the linear solver's ILU preconditioner"); ("The maximum number of iterations of the linear solver");
EWOMS_REGISTER_PARAM(TypeTag, std::string, MiluVariant, "Specify which variant of the modified-ILU preconditioner ought to be used. Possible variants are: ILU (default, plain ILU), MILU_1 (lump diagonal with dropped row entries), MILU_2 (lump diagonal with the sum of the absolute values of the dropped row entries), MILU_3 (if diagonal is positive add sum of dropped row entrires. Otherwise subtract them), MILU_4 (if diagonal is positive add sum of dropped row entrires. Otherwise do nothing"); Parameters::registerParam<TypeTag, Properties::LinearSolverRestart>
EWOMS_REGISTER_PARAM(TypeTag, bool, IluRedblack, "Use red-black partitioning for the ILU preconditioner"); ("The number of iterations after which GMRES is restarted");
EWOMS_REGISTER_PARAM(TypeTag, bool, IluReorderSpheres, "Whether to reorder the entries of the matrix in the red-black ILU preconditioner in spheres starting at an edge. If false the original ordering is preserved in each color. Otherwise why try to ensure D4 ordering (in a 2D structured grid, the diagonal elements are consecutive)."); Parameters::registerParam<TypeTag, Properties::LinearSolverVerbosity>
EWOMS_REGISTER_PARAM(TypeTag, bool, UseGmres, "Use GMRES as the linear solver"); ("The verbosity level of the linear solver (0: off, 2: all)");
EWOMS_REGISTER_PARAM(TypeTag, bool, LinearSolverIgnoreConvergenceFailure, "Continue with the simulation like nothing happened after the linear solver did not converge"); Parameters::registerParam<TypeTag, Properties::IluRelaxation>
EWOMS_REGISTER_PARAM(TypeTag, bool, ScaleLinearSystem, "Scale linear system according to equation scale and primary variable types"); ("The relaxation factor of the linear solver's ILU preconditioner");
EWOMS_REGISTER_PARAM(TypeTag, std::string, LinearSolver, "Configuration of solver. Valid options are: ilu0 (default), dilu, cprw, cpr (an alias for cprw), cpr_quasiimpes, cpr_trueimpes, cpr_trueimpesanalytic, amg or hybrid (experimental). Alternatively, you can request a configuration to be read from a JSON file by giving the filename here, ending with '.json.'"); Parameters::registerParam<TypeTag, Properties::IluFillinLevel>
EWOMS_REGISTER_PARAM(TypeTag, bool, LinearSolverPrintJsonDefinition, "Write the JSON definition of the linear solver setup to the DBG file."); ("The fill-in level of the linear solver's ILU preconditioner");
EWOMS_REGISTER_PARAM(TypeTag, int, CprReuseSetup, "Reuse preconditioner setup. Valid options are 0: recreate the preconditioner for every linear solve, 1: recreate once every timestep, 2: recreate if last linear solve took more than 10 iterations, 3: never recreate, 4: recreated every CprReuseInterval"); Parameters::registerParam<TypeTag, Properties::MiluVariant>
EWOMS_REGISTER_PARAM(TypeTag, int, CprReuseInterval, "Reuse preconditioner interval. Used when CprReuseSetup is set to 4, then the preconditioner will be fully recreated instead of reused every N linear solve, where N is this parameter."); ("Specify which variant of the modified-ILU preconditioner ought to be used. "
EWOMS_REGISTER_PARAM(TypeTag, std::string, AcceleratorMode, "Choose a linear solver, usage: '--accelerator-mode=[none|cusparse|opencl|amgcl|rocalution|rocsparse]'"); "Possible variants are: ILU (default, plain ILU), "
EWOMS_REGISTER_PARAM(TypeTag, int, BdaDeviceId, "Choose device ID for cusparseSolver or openclSolver, use 'nvidia-smi' or 'clinfo' to determine valid IDs"); "MILU_1 (lump diagonal with dropped row entries), "
EWOMS_REGISTER_PARAM(TypeTag, int, OpenclPlatformId, "Choose platform ID for openclSolver, use 'clinfo' to determine valid platform IDs"); "MILU_2 (lump diagonal with the sum of the absolute values of the dropped row entries), "
EWOMS_REGISTER_PARAM(TypeTag, bool, OpenclIluParallel, "Parallelize ILU decomposition and application on GPU"); "MILU_3 (if diagonal is positive add sum of dropped row entries, otherwise subtract them), "
"MILU_4 (if diagonal is positive add sum of dropped row entries, otherwise do nothing");
Parameters::registerParam<TypeTag, Properties::IluRedblack>
("Use red-black partitioning for the ILU preconditioner");
Parameters::registerParam<TypeTag, Properties::IluReorderSpheres>
("Whether to reorder the entries of the matrix in the red-black "
"ILU preconditioner in spheres starting at an edge. "
"If false the original ordering is preserved in each color. "
"Otherwise why try to ensure D4 ordering (in a 2D structured grid, "
"the diagonal elements are consecutive).");
Parameters::registerParam<TypeTag, Properties::UseGmres>
("Use GMRES as the linear solver");
Parameters::registerParam<TypeTag, Properties::LinearSolverIgnoreConvergenceFailure>
("Continue with the simulation like nothing happened "
"after the linear solver did not converge");
Parameters::registerParam<TypeTag, Properties::ScaleLinearSystem>
("Scale linear system according to equation scale and primary variable types");
Parameters::registerParam<TypeTag, Properties::LinearSolver>
("Configuration of solver. Valid options are: ilu0 (default), "
"dilu, cprw, cpr (an alias for cprw), cpr_quasiimpes, "
"cpr_trueimpes, cpr_trueimpesanalytic, amg or hybrid (experimental). "
"Alternatively, you can request a configuration to be read from a "
"JSON file by giving the filename here, ending with '.json.'");
Parameters::registerParam<TypeTag, Properties::LinearSolverPrintJsonDefinition>
("Write the JSON definition of the linear solver setup to the DBG file.");
Parameters::registerParam<TypeTag, Properties::CprReuseSetup>
("Reuse preconditioner setup. Valid options are "
"0: recreate the preconditioner for every linear solve, "
"1: recreate once every timestep, "
"2: recreate if last linear solve took more than 10 iterations, "
"3: never recreate, "
"4: recreated every CprReuseInterval");
Parameters::registerParam<TypeTag, Properties::CprReuseInterval>
("Reuse preconditioner interval. Used when CprReuseSetup is set to 4, "
"then the preconditioner will be fully recreated instead of reused "
"every N linear solve, where N is this parameter.");
Parameters::registerParam<TypeTag, Properties::AcceleratorMode>
("Choose a linear solver, usage: "
"'--accelerator-mode=[none|cusparse|opencl|amgcl|rocalution|rocsparse]'");
Parameters::registerParam<TypeTag, Properties::BdaDeviceId>
("Choose device ID for cusparseSolver or openclSolver, "
"use 'nvidia-smi' or 'clinfo' to determine valid IDs");
Parameters::registerParam<TypeTag, Properties::OpenclPlatformId>
("Choose platform ID for openclSolver, use 'clinfo' "
"to determine valid platform IDs");
Parameters::registerParam<TypeTag, Properties::OpenclIluParallel>
("Parallelize ILU decomposition and application on GPU");
} }
FlowLinearSolverParameters() { reset(); } FlowLinearSolverParameters() { reset(); }

83
opm/simulators/timestepping/AdaptiveTimeStepping.hpp
View File

@ -305,40 +305,55 @@ std::set<std::string> consistentlyFailingWells(const std::vector<StepReport>& sr
{ {
registerEclTimeSteppingParameters<TypeTag>(); registerEclTimeSteppingParameters<TypeTag>();
// TODO: make sure the help messages are correct (and useful) // TODO: make sure the help messages are correct (and useful)
EWOMS_REGISTER_PARAM(TypeTag, bool, SolverContinueOnConvergenceFailure, Parameters::registerParam<TypeTag, Properties::SolverContinueOnConvergenceFailure>
"Continue instead of stop when minimum solver time step is reached"); ("Continue instead of stop when minimum solver time step is reached");
EWOMS_REGISTER_PARAM(TypeTag, int, SolverMaxRestarts, Parameters::registerParam<TypeTag, Properties::SolverMaxRestarts>
"The maximum number of breakdowns before a substep is given up and the simulator is terminated"); ("The maximum number of breakdowns before a substep is given up and "
EWOMS_REGISTER_PARAM(TypeTag, int, SolverVerbosity, "the simulator is terminated");
"Specify the \"chattiness\" of the non-linear solver itself"); Parameters::registerParam<TypeTag, Properties::SolverVerbosity>
EWOMS_REGISTER_PARAM(TypeTag, int, TimeStepVerbosity, ("Specify the \"chattiness\" of the non-linear solver itself");
"Specify the \"chattiness\" during the time integration"); Parameters::registerParam<TypeTag, Properties::TimeStepVerbosity>
EWOMS_REGISTER_PARAM(TypeTag, double, InitialTimeStepInDays, ("Specify the \"chattiness\" during the time integration");
"The size of the initial time step in days"); Parameters::registerParam<TypeTag, Properties::InitialTimeStepInDays>
EWOMS_REGISTER_PARAM(TypeTag, bool, FullTimeStepInitially, ("The size of the initial time step in days");
"Always attempt to finish a report step using a single substep"); Parameters::registerParam<TypeTag, Properties::FullTimeStepInitially>
EWOMS_REGISTER_PARAM(TypeTag, std::string, TimeStepControl, ("Always attempt to finish a report step using a single substep");
"The algorithm used to determine time-step sizes. valid options are: 'pid' (default), 'pid+iteration', 'pid+newtoniteration', 'iterationcount', 'newtoniterationcount' and 'hardcoded'"); Parameters::registerParam<TypeTag, Properties::TimeStepControl>
EWOMS_REGISTER_PARAM(TypeTag, double, TimeStepControlTolerance, ("The algorithm used to determine time-step sizes. "
"The tolerance used by the time step size control algorithm"); "Valid options are: "
EWOMS_REGISTER_PARAM(TypeTag, int, TimeStepControlTargetIterations, "'pid' (default), "
"The number of linear iterations which the time step control scheme should aim for (if applicable)"); "'pid+iteration', "
EWOMS_REGISTER_PARAM(TypeTag, int, TimeStepControlTargetNewtonIterations, "'pid+newtoniteration', "
"The number of Newton iterations which the time step control scheme should aim for (if applicable)"); "'iterationcount', "
EWOMS_REGISTER_PARAM(TypeTag, double, TimeStepControlDecayRate, "'newtoniterationcount' "
"The decay rate of the time step size of the number of target iterations is exceeded"); "and 'hardcoded'");
EWOMS_REGISTER_PARAM(TypeTag, double, TimeStepControlGrowthRate, Parameters::registerParam<TypeTag, Properties::TimeStepControlTolerance>
"The growth rate of the time step size of the number of target iterations is undercut"); ("The tolerance used by the time step size control algorithm");
EWOMS_REGISTER_PARAM(TypeTag, double, TimeStepControlDecayDampingFactor, Parameters::registerParam<TypeTag, Properties::TimeStepControlTargetIterations>
"The decay rate of the time step decrease when the target iterations is exceeded"); ("The number of linear iterations which the time step control scheme "
EWOMS_REGISTER_PARAM(TypeTag, double, TimeStepControlGrowthDampingFactor, "should aim for (if applicable)");
"The growth rate of the time step increase when the target iterations is undercut"); Parameters::registerParam<TypeTag, Properties::TimeStepControlTargetNewtonIterations>
EWOMS_REGISTER_PARAM(TypeTag, std::string, TimeStepControlFileName, ("The number of Newton iterations which the time step control scheme "
"The name of the file which contains the hardcoded time steps sizes"); "should aim for (if applicable)");
EWOMS_REGISTER_PARAM(TypeTag, double, MinTimeStepBeforeShuttingProblematicWellsInDays, Parameters::registerParam<TypeTag, Properties::TimeStepControlDecayRate>
"The minimum time step size in days for which problematic wells are not shut"); ("The decay rate of the time step size of the number of "
EWOMS_REGISTER_PARAM(TypeTag, double, MinTimeStepBasedOnNewtonIterations, "target iterations is exceeded");
"The minimum time step size (in days for field and metric unit and hours for lab unit) can be reduced to based on newton iteration counts"); Parameters::registerParam<TypeTag, Properties::TimeStepControlGrowthRate>
("The growth rate of the time step size of the number of "
"target iterations is undercut");
Parameters::registerParam<TypeTag, Properties::TimeStepControlDecayDampingFactor>
("The decay rate of the time step decrease when the "
"target iterations is exceeded");
Parameters::registerParam<TypeTag, Properties::TimeStepControlGrowthDampingFactor>
("The growth rate of the time step increase when the "
"target iterations is undercut");
Parameters::registerParam<TypeTag, Properties::TimeStepControlFileName>
("The name of the file which contains the hardcoded time steps sizes");
Parameters::registerParam<TypeTag, Properties::MinTimeStepBeforeShuttingProblematicWellsInDays>
("The minimum time step size in days for which problematic wells are not shut");
Parameters::registerParam<TypeTag, Properties::MinTimeStepBasedOnNewtonIterations>
("The minimum time step size (in days for field and metric unit and hours for lab unit) "
"can be reduced to based on newton iteration counts");
} }
/** \brief step method that acts like the solver::step method /** \brief step method that acts like the solver::step method

31
opm/simulators/timestepping/EclTimeSteppingParams.hpp
View File

@ -115,20 +115,23 @@ namespace Opm {
template<class TypeTag> template<class TypeTag>
void registerEclTimeSteppingParameters() void registerEclTimeSteppingParameters()
{ {
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableTuning, Parameters::registerParam<TypeTag, Properties::EnableTuning>
"Honor some aspects of the TUNING keyword."); ("Honor some aspects of the TUNING keyword.");
EWOMS_REGISTER_PARAM(TypeTag, double, SolverGrowthFactor, Parameters::registerParam<TypeTag, Properties::SolverGrowthFactor>
"The factor time steps are elongated after a successful substep"); ("The factor time steps are elongated after a successful substep");
EWOMS_REGISTER_PARAM(TypeTag, double, SolverMaxGrowth, Parameters::registerParam<TypeTag, Properties::SolverMaxGrowth>
"The maximum factor time steps are elongated after a report step"); ("The maximum factor time steps are elongated after a report step");
EWOMS_REGISTER_PARAM(TypeTag, double, SolverMaxTimeStepInDays, Parameters::registerParam<TypeTag, Properties::SolverMaxTimeStepInDays>
"The maximum size of a time step in days"); ("The maximum size of a time step in days");
EWOMS_REGISTER_PARAM(TypeTag, double, SolverMinTimeStep, Parameters::registerParam<TypeTag, Properties::SolverMinTimeStep>
"The minimum size of a time step in days for field and metric and hours for lab. If a step cannot converge without getting cut below this step size the simulator will stop"); ("The minimum size of a time step in days for field and "
EWOMS_REGISTER_PARAM(TypeTag, double, SolverRestartFactor, "metric and hours for lab. If a step cannot converge without "
"The factor time steps are elongated after restarts"); "getting cut below this step size the simulator will stop");
EWOMS_REGISTER_PARAM(TypeTag, double, TimeStepAfterEventInDays, Parameters::registerParam<TypeTag, Properties::SolverRestartFactor>
"Time step size of the first time step after an event occurs during the simulation in days"); ("The factor time steps are elongated after restarts");
Parameters::registerParam<TypeTag, Properties::TimeStepAfterEventInDays>
("Time step size of the first time step after an event "
"occurs during the simulation in days");
} }
} // namespace Opm } // namespace Opm

2
tests/test_RestartSerialization.cpp
View File

@ -451,7 +451,7 @@ struct AquiferFixture {
}; };
AdaptiveTimeStepping<TT>::registerParameters(); AdaptiveTimeStepping<TT>::registerParameters();
BlackoilModelParameters<TT>::registerParameters(); BlackoilModelParameters<TT>::registerParameters();
EWOMS_REGISTER_PARAM(TT, bool, EnableTerminalOutput, "Do *NOT* use!"); Parameters::registerParam<TT, Properties::EnableTerminalOutput>("Do *NOT* use!");
setupParameters_<TT>(2, argv, /*registerParams=*/true); setupParameters_<TT>(2, argv, /*registerParams=*/true);
FlowGenericVanguard::setCommunication(std::make_unique<Opm::Parallel::Communication>()); FlowGenericVanguard::setCommunication(std::make_unique<Opm::Parallel::Communication>());
} }

14
tests/test_equil.cpp
View File

@ -232,13 +232,13 @@ struct EquilFixture {
#else #else
Dune::MPIHelper::instance(argc, argv); Dune::MPIHelper::instance(argc, argv);
#endif #endif
Opm::FlowGenericVanguard::setCommunication(std::make_unique<Opm::Parallel::Communication>()); using namespace Opm;
Opm::BlackoilModelParameters<TypeTag>::registerParameters(); FlowGenericVanguard::setCommunication(std::make_unique<Opm::Parallel::Communication>());
Opm::AdaptiveTimeStepping<TypeTag>::registerParameters(); BlackoilModelParameters<TypeTag>::registerParameters();
Opm::Parameters::registerParam<TypeTag, bool>("EnableTerminalOutput", AdaptiveTimeStepping<TypeTag>::registerParameters();
Opm::getPropValue<TypeTag, Opm::Properties::EnableTerminalOutput>(), Parameters::registerParam<TypeTag,
"Dummy added for the well model to compile."); Properties::EnableTerminalOutput>("Dummy added for the well model to compile.");
Opm::registerAllParameters_<TypeTag>(); registerAllParameters_<TypeTag>();
} }
using TypeTag = Opm::Properties::TTag::TestEquilTypeTag; using TypeTag = Opm::Properties::TTag::TestEquilTypeTag;

2
tests/test_glift1.cpp
View File

@ -87,7 +87,7 @@ initSimulator(const char *filename)
registerEclTimeSteppingParameters<TypeTag>(); registerEclTimeSteppingParameters<TypeTag>();
BlackoilModelParameters<TypeTag>::registerParameters(); BlackoilModelParameters<TypeTag>::registerParameters();
EWOMS_REGISTER_PARAM(TypeTag, bool, EnableTerminalOutput, "Do *NOT* use!"); Parameters::registerParam<TypeTag, Properties::EnableTerminalOutput>("Do *NOT* use!");
setupParameters_<TypeTag>(/*argc=*/sizeof(argv)/sizeof(argv[0]), argv, /*registerParams=*/true); setupParameters_<TypeTag>(/*argc=*/sizeof(argv)/sizeof(argv[0]), argv, /*registerParams=*/true);
FlowGenericVanguard::readDeck(filename); FlowGenericVanguard::readDeck(filename);