Partially Internalise AQUDIMS in Runspec

This commit internalises the items NANAQU (5) and NCAMAX (6) of the
AQUDIMS keyword into a new structure

    AquiferDimensions

hooked up to the 'Runspec' class.  This is in preparation of adding
restart output for analytic aquifers (Carter-Tracy and Fetkovich).

opm/parser/eclipse/EclipseState/Runspec.hpp

@@ -218,6 +218,36 @@ private:
     int nMaxNoBranchesConToNode;
 };
 
+class AquiferDimensions {
+public:
+    AquiferDimensions();
+    explicit AquiferDimensions(const Deck& deck);
+
+    static AquiferDimensions serializeObject();
+
+    int maxAnalyticAquifers() const
+    {
+        return this->maxNumAnalyticAquifers;
+    }
+
+    int maxAnalyticAquiferConnections() const
+    {
+        return this->maxNumAnalyticAquiferConn;
+    }
+
+    template <class Serializer>
+    void serializeOp(Serializer& serializer)
+    {
+        serializer(this->maxNumAnalyticAquifers);
+        serializer(this->maxNumAnalyticAquiferConn);
+    }
+
+private:
+    int maxNumAnalyticAquifers;
+    int maxNumAnalyticAquiferConn;
+};
+
+bool operator==(const AquiferDimensions& lhs, const AquiferDimensions& rhs);
 
 class EclHysterConfig
 {
@@ -339,6 +369,7 @@ public:
     const Welldims& wellDimensions() const noexcept;
     const WellSegmentDims& wellSegmentDimensions() const noexcept;
     const NetworkDims& networkDimensions() const noexcept;
+    const AquiferDimensions& aquiferDimensions() const noexcept;
     int eclPhaseMask( ) const noexcept;
     const EclHysterConfig& hysterPar() const noexcept;
     const Actdims& actdims() const noexcept;
@@ -357,6 +388,7 @@ public:
         welldims.serializeOp(serializer);
         wsegdims.serializeOp(serializer);
         netwrkdims.serializeOp(serializer);
+        aquiferdims.serializeOp(serializer);
         udq_params.serializeOp(serializer);
         hystpar.serializeOp(serializer);
         m_actdims.serializeOp(serializer);
@@ -372,6 +404,7 @@ private:
     Welldims welldims;
     WellSegmentDims wsegdims;
     NetworkDims netwrkdims;
+    AquiferDimensions aquiferdims;
     UDQParams udq_params;
     EclHysterConfig hystpar;
     Actdims m_actdims;

src/opm/parser/eclipse/EclipseState/Runspec.cpp

@@ -21,6 +21,7 @@
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 #include <opm/parser/eclipse/Deck/DeckSection.hpp>
 
+#include <opm/parser/eclipse/Parser/ParserKeywords/A.hpp>
 #include <opm/parser/eclipse/Parser/ParserKeywords/B.hpp>
 #include <opm/parser/eclipse/Parser/ParserKeywords/C.hpp>
 #include <opm/parser/eclipse/Parser/ParserKeywords/F.hpp>
@@ -275,6 +276,41 @@ bool NetworkDims::operator==(const NetworkDims& data) const
            this->maxNoBranchesConToNode() == data.maxNoBranchesConToNode();
 }
 
+AquiferDimensions::AquiferDimensions()
+    : maxNumAnalyticAquifers   { ParserKeywords::AQUDIMS::NANAQU::defaultValue }
+    , maxNumAnalyticAquiferConn{ ParserKeywords::AQUDIMS::NCAMAX::defaultValue }
+{}
+
+AquiferDimensions::AquiferDimensions(const Deck& deck)
+    : AquiferDimensions{}
+{
+    using AD = ParserKeywords::AQUDIMS;
+
+    if (deck.hasKeyword<AD>()) {
+        const auto& keyword = deck.getKeyword<AD>(0);
+        const auto& ad = keyword.getRecord(0);
+
+        this->maxNumAnalyticAquifers    = ad.getItem<AD::NANAQU>().get<int>(0);
+        this->maxNumAnalyticAquiferConn = ad.getItem<AD::NCAMAX>().get<int>(0);
+    }
+}
+
+AquiferDimensions AquiferDimensions::serializeObject()
+{
+    auto dim = AquiferDimensions{};
+
+    dim.maxNumAnalyticAquifers = 3;
+    dim.maxNumAnalyticAquiferConn = 10;
+
+    return dim;
+}
+
+bool operator==(const AquiferDimensions& lhs, const AquiferDimensions& rhs)
+{
+    return (lhs.maxAnalyticAquifers() == rhs.maxAnalyticAquifers())
+        && (lhs.maxAnalyticAquiferConnections() == rhs.maxAnalyticAquiferConnections());
+}
+
 EclHysterConfig::EclHysterConfig(const Opm::Deck& deck)
     {
 
@@ -456,6 +492,7 @@ Runspec Runspec::serializeObject()
     result.endscale = EndpointScaling::serializeObject();
     result.welldims = Welldims::serializeObject();
     result.wsegdims = WellSegmentDims::serializeObject();
+    result.aquiferdims = AquiferDimensions::serializeObject();
     result.udq_params = UDQParams::serializeObject();
     result.hystpar = EclHysterConfig::serializeObject();
     result.m_actdims = Actdims::serializeObject();
@@ -497,6 +534,11 @@ const NetworkDims& Runspec::networkDimensions() const noexcept
     return this->netwrkdims;
 }
 
+const AquiferDimensions& Runspec::aquiferDimensions() const noexcept
+{
+    return this->aquiferdims;
+}
+
 const EclHysterConfig& Runspec::hysterPar() const noexcept
 {
     return this->hystpar;
@@ -542,6 +584,7 @@ bool Runspec::operator==(const Runspec& data) const {
            this->endpointScaling() == data.endpointScaling() &&
            this->wellDimensions() == data.wellDimensions() &&
            this->wellSegmentDimensions() == data.wellSegmentDimensions() &&
+          (this->aquiferDimensions() == data.aquiferDimensions()) &&
            this->hysterPar() == data.hysterPar() &&
            this->actdims() == data.actdims() &&
            this->saturationFunctionControls() == data.saturationFunctionControls() &&

tests/parser/RunspecTests.cpp

@@ -527,6 +527,79 @@ WSEGDIMS
     BOOST_CHECK_EQUAL(wsd.maxLateralBranchesPerWell(), 33); // WSEGDIMS(3)
 }
 
+BOOST_AUTO_TEST_CASE(AQUDIMS_FullSpec)
+{
+    const auto input = std::string {
+        R"(
+RUNSPEC
+
+AQUDIMS
+-- 1 2 3 4 5 6 7  8
+   3 4 5 6 7 8 9 10 /
+)" };
+
+    const auto ad = AquiferDimensions {
+        Parser{}.parseString(input)
+    };
+
+    BOOST_CHECK_EQUAL(ad.maxAnalyticAquifers(), 7);           // AQUDIMS(5)
+    BOOST_CHECK_EQUAL(ad.maxAnalyticAquiferConnections(), 8); // AQUDIMS(6)
+}
+
+BOOST_AUTO_TEST_CASE(AQUDIMS_AllDefaulted)
+{
+    const auto input = std::string {
+        R"(
+RUNSPEC
+
+AQUDIMS
+/
+)" };
+
+    const auto ad = AquiferDimensions {
+        Parser{}.parseString(input)
+    };
+
+    BOOST_CHECK_EQUAL(ad.maxAnalyticAquifers(), 1);           // AQUDIMS(5): Default = 1
+    BOOST_CHECK_EQUAL(ad.maxAnalyticAquiferConnections(), 1); // AQUDIMS(6): Default = 1
+}
+
+BOOST_AUTO_TEST_CASE(AQUDIMS_MaxAnalyticAquifers)
+{
+    const auto input = std::string {
+        R"(
+RUNSPEC
+
+AQUDIMS
+-- 1 2 3 4 5
+   4*      1729 /
+)" };
+
+    const auto ad = AquiferDimensions {
+        Parser{}.parseString(input)
+    };
+
+    BOOST_CHECK_EQUAL(ad.maxAnalyticAquifers(), 1729); // AQUDIMS(5)
+}
+
+BOOST_AUTO_TEST_CASE(AQUDIMS_MaxAnalyticAquiferConnections)
+{
+    const auto input = std::string {
+        R"(
+RUNSPEC
+
+AQUDIMS
+-- 1 2 3 4 5 6
+   5*        42 /
+)" };
+
+    const auto ad = AquiferDimensions {
+        Parser{}.parseString(input)
+    };
+
+    BOOST_CHECK_EQUAL(ad.maxAnalyticAquiferConnections(), 42); // AQUDIMS(6)
+}
+
 BOOST_AUTO_TEST_CASE( SWATINIT ) {
     const std::string input = R"(
     SWATINIT