Merge pull request #481 from atgeirr/fix-summary-output

Fix summary output, now contains output for all steps.

opm/core/io/eclipse/EclipseWriter.cpp

@@ -575,6 +575,12 @@ private:
               fortio_fclose) { }
 };
 
+} // anonymous namespace
+
+// Note: the following parts were taken out of the anonymous
+// namespace, since EclipseSummary is now used as a pointer member in
+// EclipseWriter and forward declared in EclipseWriter.hpp.
+
 // forward decl. of mutually dependent type
 struct EclipseWellReport;
 
@@ -655,6 +661,7 @@ private:
     }
 };
 
+
 // in order to get RTTI for this "class" (which is just a typedef), we must
 // ask the compiler to explicitly instantiate it.
 template struct EclipseHandle<ecl_sum_tstep_struct>;
@@ -670,7 +677,7 @@ protected:
                        PhaseUsage uses,                  /* phases present     */
                        BlackoilPhases::PhaseIndex phase, /* oil, water or gas  */
                        WellType type,                    /* prod. or inj.      */
-                       char aggregation,                 /* rate or total      */
+                       char aggregation,                 /* rate or total or BHP */
                        std::string unit)
         : EclipseHandle <smspec_node_type> (
               ecl_sum_add_var (summary,
@@ -718,22 +725,26 @@ private:
                          char aggregation) {
         std::string name;
         name += 'W'; // well
-        switch (phase) {
+        if (aggregation == 'B') {
+            name += "BHP";
+        } else {
+            switch (phase) {
             case BlackoilPhases::Aqua:   name += 'W'; break; /* water */
             case BlackoilPhases::Vapour: name += 'G'; break; /* gas */
             case BlackoilPhases::Liquid: name += 'O'; break; /* oil */
             default:
                 OPM_THROW(std::runtime_error,
                           "Unknown phase used in blackoil reporting");
-        }
-        switch (type) {
+            }
+            switch (type) {
             case WellType::INJECTOR: name += 'I'; break;
             case WellType::PRODUCER: name += 'P'; break;
             default:
                 OPM_THROW(std::runtime_error,
                           "Unknown well type used in blackoil reporting");
+            }
+            name += aggregation; /* rate ('R') or total ('T') */
         }
-        name += aggregation; /* rate ('R') or total ('T') */
         return name;
     }
 protected:
@@ -743,6 +754,13 @@ protected:
         const double value = sign_ * wellState.wellRates () [index_] * convFactor;
         return value;
     }
+
+    double bhp (const WellState& wellstate) {
+        // Note that 'index_' is used here even though it is meant
+        // to give a (well,phase) pair.
+        const int num_phases = wellstate.wellRates().size() / wellstate.bhp().size();
+        return wellstate.bhp()[index_/num_phases];
+    }
 };
 
 /// Monitors the rate given by a well.
@@ -805,6 +823,31 @@ private:
     double total_;
 };
 
+/// Monitors the bottom hole pressure in a well.
+struct EclipseWellBhp : public EclipseWellReport {
+    EclipseWellBhp   (const EclipseSummary& summary,
+                      const EclipseGridParser& parser,
+                      int whichWell,
+                      PhaseUsage uses,
+                      BlackoilPhases::PhaseIndex phase,
+                      WellType type)
+        : EclipseWellReport (summary,
+                             parser,
+                             whichWell,
+                             uses,
+                             phase,
+                             type,
+                             'B',
+                             "Pascal")
+    { }
+
+    virtual double update (const SimulatorTimer& timer,
+                           const WellState& wellState)
+    {
+        return bhp(wellState);
+    }
+};
+
 inline void
 EclipseSummary::writeTimeStep (const SimulatorTimer& timer,
                                const WellState& wellState) {
@@ -861,8 +904,30 @@ EclipseSummary::addWells (const EclipseGridParser& parser,
             }
         }
     }
+
+    // Add BHP monitors
+    for (int whichWell = 0; whichWell != numWells; ++whichWell) {
+        // In the call below: uses, phase and the well type arguments
+        // are not used, except to set up an index that stores the
+        // well indirectly. For details see the implementation of the
+        // EclipseWellReport constructor, and the method
+        // EclipseWellReport::bhp().
+        BlackoilPhases::PhaseIndex phase = BlackoilPhases::Liquid;
+        if (!uses.phase_used[BlackoilPhases::Liquid]) {
+            phase = BlackoilPhases::Vapour;
+        }
+        add (std::unique_ptr <EclipseWellReport> (
+                        new EclipseWellBhp (*this,
+                                            parser,
+                                            whichWell,
+                                            uses,
+                                            phase,
+                                            WELL_TYPES[0])));
+    }
 }
 
+namespace {
+
 /// Helper method that can be used in keyword transformation (must curry
 /// the barsa argument)
 static double toBar (const double& pressure) {
@@ -902,6 +967,11 @@ void EclipseWriter::writeInit(const SimulatorTimer &timer,
 
     /* Initial solution (pressure and saturation) */
     writeSolution (timer, reservoirState, wellState);
+
+    /* Create summary object (could not do it at construction time,
+       since it requires knowledge of the start time). */
+    summary_.reset(new EclipseSummary(outputDir_, baseName_, timer, *parser_));
+    summary_->addWells (*parser_, uses_);
 }
 
 void EclipseWriter::writeSolution (const SimulatorTimer& timer,
@@ -952,9 +1022,15 @@ void EclipseWriter::writeTimeStep(const SimulatorTimer& timer,
     // (first timestep, in practice), and reused later. but how to do this
     // without keeping the complete summary in memory (which will then
     // accumulate all the timesteps)?
-    EclipseSummary sum (outputDir_, baseName_, timer, *parser_);
-    sum.addWells (*parser_, uses_);
-    sum.writeTimeStep (timer, wellState);
+    //
+    // Note: The answer to the question above is still not settled,
+    // but now we do keep the complete summary in memory, as a member
+    // variable in the EclipseWriter class, instead of creating a
+    // temporary EclipseSummary in this function every time it is
+    // called.  This has been changed so that the final summary file
+    // will contain data from the whole simulation, instead of just
+    // the last step.
+    summary_->writeTimeStep (timer, wellState);
 }
 
 #else

opm/core/io/eclipse/EclipseWriter.hpp

@@ -28,6 +28,7 @@
 #include <memory>  // std::unique_ptr
 
 struct UnstructuredGrid;
+struct EclipseSummary;
 
 namespace Opm {
 
@@ -90,6 +91,7 @@ private:
     std::string outputDir_;
     std::string baseName_;
     PhaseUsage uses_;           // active phases in the input deck
+    std::shared_ptr <EclipseSummary> summary_;
 
     /// Write solution field variables (pressure and saturation)
     void writeSolution (const SimulatorTimer& timer,